Récupération automatique de classes?...

#include <iostream>
#include <vector>

class Animation
{
public:
  virtual void display() const = 0;
  Animation() {}
  ~Animation() {}
};

class Anim1 : public Animation
{
public:
  void display() const
  {
    std::cout << "kikoo Anim1" << std::endl;
  }
  Anim1() {}
  ~Anim1() {}
};

class Anim2 : public Animation
{
public:
  void display() const
  {
    std::cout << "kikoo Anim2" << std::endl;
  }
  Anim2() {}
  ~Anim2() {}
};

class Anim3 : public Animation
{
public:
  void display() const
  {
    std::cout << "kikoo Anim3" << std::endl;
  }
  Anim3() {}
  ~Anim3() {}
};

class GroupAnim
{
  typedef std::vector<Animation*>::iterator iter;
  typedef std::vector<Animation*>::const_iterator const_iter;

public:
  GroupAnim()
  {
    /*
      Il faut tenir cette liste à jour
     */
    _list.push_back(new Anim1);
    _list.push_back(new Anim2);
    _list.push_back(new Anim3);
  }

  int size() const
  {
    return _list.size();
  }

  void display() const
  {
    for (const_iter it = _list.begin(); it != _list.end(); ++it)
      (*it)->display();
  }

  ~GroupAnim()
  {
    for (iter it = _list.begin(); it != _list.end(); ++it)
      delete *it;
  }
private:
  std::vector<Animation*> _list;
};

int main()
{
  GroupAnim group; // Can be a singleton

  std::cout << "Size: " << group.size() << std::endl;
  group.display();

  return 0;
}

/*__________________________________________________________
*/
#include <iostream>
#include <list>
/*__________________________________________________________
*/
class Anim
{
public:
	virtual void do_something() = 0 ;
};
/*__________________________________________________________
*/
class Anim1 : public Anim 
{ 
	friend class builder ;
private:
	Anim1(){}
	virtual ~Anim1(){}

public:
	void do_something() 
	{
		std::cout << "Anim1::do_something()" << std::endl ;
	}
};
/*__________________________________________________________
*/
class Anim2 : public Anim 
{ 
	friend class builder ;
private:
	Anim2(){}
	virtual ~Anim2(){}

public:
	void do_something() 
	{
		std::cout << "Anim2::do_something()" << std::endl ;
	}
};
/*__________________________________________________________
*/
class Anim3 : public Anim 
{ 
	friend class builder ;
private:
	Anim3(){}
	virtual ~Anim3(){}

public:
	void do_something() 
	{
		std::cout << "Anim3::do_something()" << std::endl ;
	}
};
/*__________________________________________________________
*/
class builder
{
public:
	typedef std::list<Anim*> container ;
	typedef std::list<Anim*>::const_iterator const_iterator ;

private:
	container _li ;

private:
	builder()
	{
		_li.push_back( new Anim1() ) ;
		_li.push_back( new Anim1() ) ;
		_li.push_back( new Anim2() ) ;
		_li.push_back( new Anim2() ) ;
		_li.push_back( new Anim3() ) ;
		_li.push_back( new Anim3() ) ;
	}
	virtual ~builder()
	{
		while( !_li.empty() )
		{
			delete _li.front() ;
			_li.pop_front() ;
		}
	}

public:
	static builder & instance()
	{
		static builder instance ;
		return instance ;
	}
	
	const container & get_products() const { return _li ; }
};
/*__________________________________________________________
*/
int main()
{
	//appel
	const builder::container & cont = builder::instance().get_products() ;

	//utilisation
	builder::const_iterator it ;
	for ( it = cont.begin() ; it != cont.end() ; ++it )
	{
		(*it)->do_something() ;
	}

	//destruction automatique
}/*__________________________________________________________
*/