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));
  }
};