Question

class B {
public:
    virtual void foo(?);
}
class D1 : public B {
public:
    void foo(T1*);
}
class D2 : public B {
public:
    void foo(T2*);
}

B* b1 = new D1();
B* b2 = new D2();

T1和T2可能无关。

如何设计这样的类，以便调用b1和b2以正确的类型调用正确的foo？

可以使用upto c ++ 14。

Answer 1

您希望它执行的方式可以通过以下代码实现，但在我看来并不像一个好的设计。所以，你需要重新考虑你的设计。

class T1 { 
public:
    void f() {
        cout << "Calls T1::f\n";
    }
};
class T2 {
public:
    void g() {
        cout << "Calls T2::g\n";
    }
};
class B {
public:
    virtual ~B() {}
    virtual void foo(T1* t) {/* throw some exception maybe! */}
    virtual void foo(T2* t) {/* throw some exception maybe! */}
};
class D1 : public B {
public:
    void foo(T1* t) {
        t->f();
    }
};
class D2 : public B {
public:
    void foo(T2* t) {
        t->g();
    }
};

Live demo！

Answer 2

class B {
public:
    template<class Derived, class T>
    void foo(T &&x) {
        //Crashes if can't be converted, test for nullptr maybe
        dynamic_cast<Derived*>(this)->foo(x);
    }
}

class D1 : public B<D1> {
public:
    void foo(T1*);
}
class D2 : public B<D2> {
public:
    void foo(T2*);
}

B * b1 = new D1();
B * b2 = new D2();

T1 t1;
b1->foo<D1> (&t1);

由于T1和T2没有任何关系并且不属于同一个类树，因此这意味着在调用foo时您知道 B b1的子类是。所以你只要把那个子类作为模板参数。

另一个解决方案是对void*的C风格转换:(不建议用C ++）

class B {
public:
    template<class T>
    void foo(T *x) {
        foo_handler(reinterpret_cast<void*>(x));
    }
protected:
    virtual void foo_handler(void*) = 0;
}

class D1 : public B<D1> {
public:
    void foo(T1*);
private:
    void foo_handler(void *x) {foo(reinterpret_cast<T1*>(x));}
}
class D2 : public B<D2> {
public:
    void foo(T2*);
private:
    void foo_handler(void *x) {foo(reinterpret_cast<T2*>(x));}
}

B * b1 = new D1();
B * b2 = new D2();

T1 t1;
b1->foo(&t1);

为具有不同签名的函数的派生类设计基类

2 个答案: