Question

我有一个名为

的回调函数

MyCallBack(int type)

我有3个B，C和D类，它们来自A，具有常用的方法名称目前我的代码是这样的

MyCallBack(int type){
if(type == 1 ){
B b;
b.perform();
}else if(type==2) {
C c;
c.perform();
}else if(type ==3){
D d; 
d.perform();
}

有没有办法可以减少像

这样的代码

MyCallBack(int type){
Common object(type);
object.perform();
}

Answer 1

基本上，你需要的是多态性。

您的所有课程B，C，D应来自抽象课程，并使用纯虚拟方法SuperBase说perform()。您的代码应该只使用指向SuperBase的指针，该指针包含实际具体类对象的地址一旦你有了这个，根据被指向的对象的实际类型，将调用适当的类的方法。

这种方法的优点是没有硬编码类型检查＆amp;使用Open Closed principle进行松散耦合设计的灵活性。

Answer 2

@Als使用多态的想法是一个很好的想法（IMO），但只有在之后才能从输入整数转换为实际类型。一种方法是索引到对象的指针数组：

MyCallback(int type) { static A *ptrs[] = { new B, new C, new D}; ptrs[type-1]->perform(); }

编辑：以防您不知道，为了使其正常工作，perform需要在A中声明（可能是纯粹的）虚拟虚拟函数，并在每个虚拟函数中定义B，C和D。您需要确保函数的整个签名，而不仅仅是名称，在类之间是相同的。

Answer 3

interface怎么样？

class A
{
    public:

        virtual void perform() = 0;
};

class B : public A
{
    public:

        void perform() { ... }
};

// Same for C, and D

所以你的回调就像：

MyCallBack(A& performer)
{
    performer.perform();
}

如果您无法更改回调的签名，abstract factory pattern：

怎么样？

function A* AFactory(int type)
{
    switch(type)
    {
        case 1: return new B();    // Assuming B, C, D all derive from A
        case 2: return new C();
        case 3: return new D();
        default: return nullptr;  // nullptr is a c++11 thing.  Use NULL, if you're still on C++03
    }
}

然后是回调......

MyCallBack(int type)
{
    std::unique_ptr<A> obj(AFactory(type));  // this will automatically release the memory once it falls out of scope
    obj->perform();
}

Answer 4

你应该创建Object Factory或者只是静态（全局）方法将指针（或者引用，可能）返回到基类型，但是包含派生类型的对象。

CBase* CreateObjectBasedOnType(int type)
{
    // check for type and return appriopriate derived object
}

MyCallBack(int type)
{
    CreateObjectBasedOnType(type)->perform();
}

请注意，您要调用的方法应该是虚拟的。

更好的方法可以使用模板

template<typename T>
MyCallBack()
{
    T Obj;
    Obj.perform();
}

避免在公共类中重复代码

4 个答案: