// game_object.hpp
// Корень иерархии игровых объектов. 
// Все производные от него автоматом становятся видны менеджеру и "умеют" обновляться
class game_object {
public:
    game_object() { manager::instance()->reg_object(this); }
    virtual ~game_object() { manager::instance()->unreg_object(this); }
    virtual void update() = 0;
};

// manager.hpp
// Менеджер - заправИло всех объектов. 
// Тута они регистрятся при рождении, анрегистрятся при смерти
class manager {
public:    
    typedef std::set<game_object*> objects_queue;
    static manager* instance() { return instance_ ? instance_ : instance_ = new manager(); }
    void reg_object(game_object* go)    { objects_.insert(go);    }
    void unreg_object(game_object* go)    { objects_.erase(go);    }
protected:
    manager() { }
    manager(const manager&) { }
    objects_queue objects_;
private:
    static manager* instance_;
};

// manager.cpp
manager* manager::instance_ = 0;

1. Лепим производные от game_object классы, обладающие необходимым интерфейсом, типа
   

   // serializable.hpp
   class serializable : public game_object {
   public:
       virtual void save() = 0;
       virtual void load() = 0;
   };

   
   
2. На этапе выполнения проверяем возможность вызова нужной функции
   

   // manager.hpp
   class manager {
   public:    
       /* ... */
       void save_all() { 
           for (objects_queue::iterator it = objects_.begin(); it != objects_.end(); ++it) {
               if (dynamic_cast<serializable*>(*it)) (*it)->save();
           }
       }
       /* ... */
   };

1. Менеджер посылает объекту (неизвестного ему динамического типа) сообщение (к примеру, элемент енума);
   

   // manager.hpp
   enum command { UPDATE, DRAW, SAVE, LOAD, };
   class manager {
   public:
       /* ... */
       void send(command c) {
           for (objects_queue::iterator it = objects_.begin(); it != objects_.end(); ++it) {
               (*it)->execute(c);
           }
       }
       /* ... */
   };

   
   
2. А уже объект определяет, в состоянии ли он выполнить запрос
   

   // game_object.hpp
   class game_object {
       /* ... */
       virtual void execute(command c) {
           if (c == UPDATE) update();
       }
       /* ... */
   };
   
   // serializable.hpp
   class serializable : public game_object {
   public:
       virtual void save() = 0;
       virtual void load() = 0;
       virtual void execute(command c) {
           game_object::execute(c);
           if     (c == SAVE) save();
           else if (c == LOAD) load();
       }
   };[/b]

class manager {
public:    
    typedef std::set<game_object*> objects_queue;
    static manager* instance() { return instance_ ? instance_ : instance_ = new manager(); }
    void reg_object(game_object* go)    { objects_.insert(go);    }
    void unreg_object(game_object* go)    { objects_.erase(go);    }
        
        virtual void serialize() {}
        virtual void draw() {}
        
protected:
    manager() { }
    manager(const manager&) { }
    objects_queue objects_;
private:
    static manager* instance_;
};

struct obj_desc
{
   IDrawable*     draw;
   ISerializable* serialize;
   ...
};

public:
   obj_desc* reg();

A>Боюсь, что это не решает самой проблемы, а именно: если завтра мне понадобится, чтобы менеджер умел выполнять над частью объектов еще пару операций (например, move(point), play_sound() etc.), снова придется лезть и переделывать game_object. Через несколько итераций мы получим "жирный" интерфейс: в классе game_object будет немалое количество методов-заглушек, созданных только для удовлетворения нужд какой-то ветви иерархии объектов .

class manager
{
  ...
public:
  ...

  template <typename C> total_operation(void ( C::*method)() )
  {
    C *obj;
    for (Iterator it = objects_.begin(); it != objects_.end(); it++)
    {
      obj = dynamic_cast<C*>(*it);
      if (obj) (obj->*method)();
    }
  }
};

// где-то в коде:

// *** сериализация ***
manager_instance.total_operation<serializable_object>(&serializable_object::save);

// *** отрисовка ***
manager_instance.total_operation<drawable_object>(&serializable_object::draw);

...
public:
virtual void accept(Manager* mgr);
...

... 
public:
void process(draw_game_object* object);
void process(serialize_game_object* object);
// и т.п.
...

...
mgr->process(this);
...

class game_object {
public:
  virtual void visit(object_visiter& visiter) {visiter.accept(*this);}
};

struct object_visiter {
  void accept(game_object&) {};
  //свой accept для каждого производного интерфейса
  void accept(serializable& obj) {}
  void accept(dravable& obj) {}
};

void manager::for_each(object_visiter& visiter) {
  for (objects_queue::iterator it = objects_.begin(); it != objects_.end(); ++it)
    (*it)->visit(visiter);
}

void manager::update_all() {
  struct updater_t : object_visiter {
    void accept(game_object& obj) {obj.update();}
    void accept(serializable& obj) {obj.update();}
    void accept(dravable& obj) {obj.update();}
  } updater;
  for_each(updater);
}

void manager::save_all() {
  struct saver_t : object_visiter {
    void accept(serializable& obj) {obj.save();}
  } saver;
  for_each(saver);
}

void manager::draw_all(DC dc) {
  struct draver_t : object_visiter {
    draver_t(DC dc) : dc(dc) {}
    DC dc
    void accept(dravable& obj) {obj.draw(dc);}
  } draver(dc);
  for_each(draver);
}

class manager {
...
protected:
...
    objects_queue objects_;
    drawable_queue dravables_
...
};

void manager::reg_object(game_object* go) {
  struct inserter_t : object_visiter {
    void accept(game_object& obj) {objects_.insert(obj);}
    void accept(serializable& obj) {accept(static_cast<game_object&>(obj));}
    void accept(dravable& obj) {
      accept(static_cast<game_object&>(obj));
      dravables_.insert(obj);
    }
    inserter_t(objects_queue& objects_, drawable_queue& dravables_) : 
      objects_(objects_), dravables_(dravables_) {}
    objects_queue& objects_;
    drawable_queue& dravables_
  } inserter(objects_, dravables_);
  go->visit(inserter);
}

void manager::unreg_object(game_object* go) {
  struct eraser_t : object_visiter {
    void accept(game_object& obj) {objects_.erase(obj);}
    void accept(serializable& obj) {accept(static_cast<game_object&>(obj));}
    void accept(dravable& obj) {
      accept(static_cast<game_object&>(obj));
      dravables_.erase(obj);
    }
    eraser_t(objects_queue& objects_, drawable_queue& dravables_) : 
      objects_(objects_), dravables_(dravables_) {}
    objects_queue& objects_;
    drawable_queue& dravables_
  } eraser(objects_, dravables_);
  go->visit(eraser);
}

void manager::draw_all(DC dc) {
  for (objects_queue::iterator it = objects_.begin(); it != objects_.end(); ++it)
    (*it)->draw(dc);
}

struct iface {}
typedef unsigned int iface_id;

class game_object()
{
  virtual iface* get_iface(iface_id id) = 0;
}

for_each(gobj in collection)
{
  iface_moveable *imove = gobj->get_iface(iface_moveable_id);
  if(imove)
    im->move(x,y);
}

 virtual iface* get_iface(iface_id id) 
 { 
   if(id == iface_dead && name == desdemona && ottello_was_here)
     return (iface_dead*) this; //или new iface_dead_impl(this)
     
 }
 .....

 iface_dead *idead = gobj->get_iface(iface_dead_id);
  if(idead)
    im->dissolve();

class drawable //грани для классов 
{
public:    
    virtual void doit()  = 0;
    virtual operator bool ()  = 0;
};

class serialize //тоже 
{
public:    
    virtual void doit() = 0;
    virtual operator bool () = 0;
};

template<class valueT> // обертка для класса имеющего грань
class draw_face : public drawable
{
    valueT* _p;
public:
    draw_face(valueT* src) : _p(src) {}
    virtual void doit() { _p->draw() ; }
    virtual operator bool () { return _p == 0 ; }
};

template<class valueT> //тоже обертка
class serialize_face : public serialize
{
    valueT* _p;
public:
    serialize_face(valueT* src) : _p(src) {}
    virtual void doit() { _p->serlz() ; }
    virtual operator bool () { return _p == 0 ; }
};

//базовый класс
class game_object
{
public:
    virtual operator drawable* () { return  0; }
    virtual operator serialize* () { return  0; }
};

//два класса  один моджет обе операции другой только одну

#include <iostream>

class any_game_obj : public game_object    
{
public:
    operator drawable* () { return  new  draw_face<any_game_obj>(this); }
    operator serialize* () { return  new serialize_face<any_game_obj>(this); }

    void draw() { std::cout << " any game obje :: draw"  << std::endl; }
    void serlz() {std::cout << " any game obje :: serlz"  << std::endl; }
};

class any_draw_obj : public game_object
{
public:
    operator drawable* () { return new  draw_face<any_draw_obj>(this); }    
    void draw() {std::cout << " any dwaw obj :: draw"  << std::endl; }
};

//контейнер (память не чищу либо!)

#include <list>
class engine
{
    std::list<drawable*> _drawed;
    std::list<serialize*> _serlz;

    void add_draw(drawable* src)
    {
        if ( src ) _drawed.push_back(src);
    }

    void add_serialize(serialize* src)
    {
        if ( src ) _serlz.push_back(src);
    }
public:
    void reg_obj(game_object& src)
    {
        add_serialize(src);
        add_draw(src);
    }
    void draw_all()
    {
        for ( std::list<drawable*>::iterator it = _drawed.begin();  it != _drawed.end(); ++ it)
            (*it)->doit();
    }

    void serlz_all()
    {
        for ( std::list<serialize*>::iterator it = _serlz.begin();  it != _serlz.end(); ++ it)
            (*it)->doit();
    }
};

int main()
{
    engine e;
    any_game_obj o1;
    any_draw_obj o2;
    e.reg_obj(o1);
    e.reg_obj(o2);

    e.draw_all();
    e.serlz_all();
    return 0;
}

 any game obje :: draw
 any dwaw obj :: draw
 any game obje :: serlz

dad>class drawable //грани для классов 
dad>{
dad>public:    
dad>    virtual void doit()  = 0;

//Не понятно зачем этот оператор. В дальнейшем коде он неиспользуется
dad>    virtual operator bool ()  = 0;
dad>};
........
dad>template<class valueT> // обертка для класса имеющего грань
dad>class draw_face : public drawable
dad>{
dad>    valueT* _p;
dad>public:
dad>    draw_face(valueT* src) : _p(src) {}

//Здесь видимо надо проверить на 0, (код ниже подтверждает возможность 0)
dad>    virtual void doit() { _p->draw() ; }

//Обычно равенство 0 трактуется как false а здесь наоборот
dad>    virtual operator bool () { return _p == 0 ; }
dad>};
.............
dad>class engine
dad>{
dad>    std::list<drawable*> _drawed;
dad>    std::list<serialize*> _serlz;

dad>    void add_draw(drawable* src)
dad>    {
dad>        if ( src ) _drawed.push_back(src);
//Здесь видимо подразумевался такой код:
        if ( src && *src ) _drawed.push_back(src);
dad>    }
............
dad>public:
dad>    void reg_obj(game_object& src)
dad>    {
dad>        add_serialize(src);
dad>        add_draw(src);
dad>    }

dad>    void draw_all()
dad>    {
dad>        for ( std::list<drawable*>::iterator it = _drawed.begin();  it != _drawed.end(); ++ it)
//Вот здесь происходит как минимум 2 виртуальных вызова
dad>            (*it)->doit();
dad>    }
............
dad>

// slave.hpp
template <class T>
class slave {
public:
    slave() { manager<T>::instance()->reg(static_cast<T*>(this); }
    virtual ~slave() { manager<T>::instance()->unreg(static_cast<T*>(this); }
};

// manager.hpp
template <class T>
class manager {
public:    
    typedef std::set<T*> objects_queue;
    static manager* instance() { return instance_ ? instance_ : instance_ = new manager(); }
    void reg_object(T* go)    { objects_.insert(go);    }
    void unreg_object(T* go){ objects_.erase(go);    }
    // действия над всеми объектами
    template <class func> void do_with_all(func what) { 
        std::for_each(objects_.begin(), objects_.end(), what); 
    }
    // действия над одним объектом
    template <class func> void do_with(T* go, func what) {
        if   (objects_.find(go) != objects_.end) what(go);
        else throw std::logic_error("some problems here");
    };
protected:
    manager() { }
    manager(const manager&) { }
    objects_queue objects_;
private:
    static manager* instance_;
};

///////////////////////////////////////////////////////////////////////////////
// Клепать классы, поддерживающие нужный интерфейс и автоматом регистрирующиеся 
// у соответствующего менеджера теперь проще простого:
///////////////////////////////////////////////////////////////////////////////

// drawable.hpp
// Базовый класс для всех объектов, подлежащих отрисовке
class drawable 
    : public slave<drawable> {
public:
    virtual void draw() { render_system::instance()->draw(sprite_, coords_); }
protected:
    sprite*     sprite_;
    rectangle<real> coords_;
};

// updateable.hpp
// Базовый класс для всех объектов, состояник которых нужно обновлять.
class updateable 
    : public slave<updateable> {
public:
    virtual void update() = 0;
};

///////////////////////////////////////////////////////////////////////////////
// Пример клиентского кода
///////////////////////////////////////////////////////////////////////////////

// waypoint.hpp
class waypoint 
    : public updateable {
public:
    virtual void update() { std::cout << "waypoint was updated" << std::endl; }    
};

// soldier.hpp
class soldier 
    : public updateable
    , public drawable {
public:
    virtual void update() { std::cout << "soldier was updated" << std::endl; }
    virtual void draw()   { std::cout << "soldier was drawn" << std::endl; }
}

// main.cpp
int main()
{
    soldier*  s1 = new soldier;
    soldier*  s2 = new soldier;
    waypoint* wp = new waypoint;

    manager<updateable>::instance()->do_with_all(std::mem_fun(updateable::update));
    std::cout << std::endl;
    manager<drawable>::instance()->do_with_all(std::mem_fun(drawable::draw));
}

soldier was updated
soldier was updated
waypoint was updated

soldier was drawn
soldier was drawn

class any : public game_object
     , public serializable
     , public drawable 
{ ->visit(v) { v->accept(*this);  };

struct inserter_t : object_visiter {
void accept(game_object& obj) //{objects_.insert(obj);}
void accept(serializable& obj)// {accept(static_cast<game_object&>(obj));}
void accept(dravable& obj) // {

dad>class any : public game_object
dad>     , public serializable
dad>     , public drawable 
dad>{ ->visit(v) { v->accept(*this);  };

dad>struct inserter_t : object_visiter {
dad>void accept(game_object& obj) //{objects_.insert(obj);}
dad>void accept(serializable& obj)// {accept(static_cast<game_object&>(obj));}
dad>void accept(dravable& obj) // {
dad>

struct object_visiter {
..........
  virtual void accept(any& obj) {}
..........
};

class any : public game_object, public serializable, public drawable {
public:
  virtual void visit(object_visiter& visiter) {
    visiter.accept(static_cast<game_object*>(*this));
    visiter.accept(static_cast<serializable*>(*this));
    visiter.accept(static_cast<drawable*>(*this));
  }
};