如何做到这一点自动？

Question

有没有办法为所有派生类自动执行此操作，我不必为所有嵌套类创建函数applyPack。

这是一张我的代码：

/** every class has registered id with this function */ 
template<typename T> 
uint getID() { 
    static uint id = registerClass<T>(); 
    return id; 
} 

class TemplatesPack { 
public: 
    template<typename T> 
    typename T::Template get(); 
}; 

class Object { 
public: 
    virtual void applyPack(TemplatesPack *p) { this->setTemplate(p->get<Object>()); }; 
}; 

class Object2: public Object { 
public: 
    void applyPack(TemplatesPack *p) { this->setTemplate(p->get<Object2>()); }; 
}; 

class Object3: public Object { 
public: 
    void applyPack(TemplatesPack *p) { this->setTemplate(p->get<Object3>()); }; 
}; 

class Object4: public Object2 { 
public: 
    void applyPack(TemplatesPack *p) { this->setTemplate(p->get<Object4>()); }; 
}; 

我读过一些关于类型的特征，但我不希望有Object类模板。这可以用C++完成，并在类TemplatesPack或C++ 0x中模板化一些函数？ s

Answer 1

编辑：
改变了答案，使对象不变。

template<class T> 
class Base<T> : public Object 
{ 
public: 
    virtual void applyPack(TemplatePack *p) { this->setTemplate(p->get<T>()); }; 
}; 

class Object2 : public Base<Object2> 
{ 
    // ... 
}; 

编辑：为Object4的情况下，也许下面将帮助：

template<class S, class D> 
class Base<S, D> : public S 
{ 
public: 
    virtual void applyPack(TemplatePack *p) { this->setTemplate(p->get<D>()); }; 
}; 

class Object2 : public Base<Object, Object2> { /* ... */ }; 

class Object3 : public Base<Object, Object3> { /* ... */ }; 

class Object4 : public Base<Object2, Object4> { /* ... */ }; 

Answer 2

你可以使用虚拟继承和显性规则，如果你不希望模板化Base

template<typename Derived, typename Base = void> 
struct applyer : virtual applyer<Base, typename Base::base_type> { 
    virtual void applyPack(TemplatesPack *p) { 
    dynamic_cast<Derived*>(this)->setTemplate(p->get<Derived>()); 
    }; 

    typedef Base base_type; 
}; 

template<typename Derived> 
struct applyer<Derived, void> { 
    virtual void applyPack(TemplatesPack *p) { 
    dynamic_cast<Derived*>(this)->setTemplate(p->get<Derived>()); 
    }; 
}; 

现在您可以按如下方式操作

class Object : virtual public applyer<Object> { 

}; 

class Object2: public Object, virtual public applyer<Object2, Object> { 

}; 

class Object3: public Object, virtual public applyer<Object3, Object> { 

}; 

第二个参数分别是直接基类，如果没有的话可以省略。例如，如果你从Object3派生，你需要这样做，如下所示

class Object3_1: public Object3, virtual public applyer<Object3_1, Object3> { 

};