Question

上下文：当出现以下问题时，我正在讨论C＃与Java的工作，我想知道如何（或者如果）在C ++中优雅地解决它。

假设您有两个类A和B（其详细信息并不重要），然后将两个模板化的类G和H描述为：

template <typename T>            | template <typename T> 
class G                          | class H
{                                | {
   public :                      |    public :
      T * foo() ;                |       virtual T * foo() = 0 ;
      // etc.                    |       // etc.
} ;                              | } ;

然后我们将课程C和D描述为：

class A { /* ... */ } ;
class B { /* ... */ } ;

class C : public G<A>, public G<B>
{
} ;

class D : public H<A>, public H<B>
{
   // ???
} ;

我希望能够C从foo呼叫G<A>方法，从G<B>呼叫foo。我希望能够从D和foo覆盖H<A>方法H<B>。

最后，我希望能够在以下示例中使用C和D：

C c ;
A * a = c.??? ; (I want to call G<A>::foo())
B * b = c.??? ; (I want to call G<B>::foo())

D d ;
A * a = c.??? ; (I want to call H<A>::foo())
B * b = c.??? ; (I want to call H<B>::foo())

总有很多方法可以做到（而且我有一些想法），但我对一系列优雅而安全的方法感兴趣，包括优点/缺点。

那么，你会怎么做？

Answer 1

我能想到的两种方式：

C x;

x.G<A>::foo(); // 1
static_cast<G<A>&>(x).foo(); // 2

即：明确限定函数的名称，或者在类型层次结构中进行upcast。

Answer 2

怎么样，重载和使用不同的参数：

template <typename T>
class G
{
public:
    T * foo(T &a) {/* ... */};
    // etc.
};

class A
{
public:
    /* ... */
};

class B
{
    public:
    /* ... */
};

class C : public G<A>, public G<B>
{
public:
    using G<A>::foo;
    using G<B>::foo;

};

int main()
{
    C c;

    A a;
    B b;

    c.foo(a);
    c.foo(b);

    return 0;
}

C ++多重继承函数名称冲突

2 个答案: