Question

我不确定要使用的术语，但这是我的例子：

class Base {
public:
    virtual void test() = 0;
};

class Mixin {
public:
    virtual void test() { }
};

class Example : public Base, public Mixin {
};

int main(int argc, char** argv) {
    Example example;
    example.test();
    return 0;
}

我希望我的Mixin类实现纯虚函数Base::test，但是当我编译它时，它说：

test.cpp: In function ‘int main(int, char**)’:
test.cpp:15:13: error: cannot declare variable ‘example’ to be of abstract type ‘Example’
     Example example;
             ^
test.cpp:11:7: note:   because the following virtual functions are pure within ‘Example’:
 class Example : public Base, public Mixin {
       ^
test.cpp:3:18: note:    virtual void Base::test()
     virtual void test() = 0;
                  ^
test.cpp:16:13: error: request for member ‘test’ is ambiguous
     example.test();
             ^
test.cpp:8:18: note: candidates are: virtual void Mixin::test()
     virtual void test() { }
                  ^
test.cpp:3:18: note:                 virtual void Base::test()
     virtual void test() = 0;
                  ^

我可以添加using语句，使其不含糊：

class Example : public Base, public Mixin {
public:
    using Mixin::test;
};

但它说我还没有实现它：

test.cpp: In function ‘int main(int, char**)’:
test.cpp:17:13: error: cannot declare variable ‘example’ to be of abstract type ‘Example’
     Example example;
             ^
test.cpp:11:7: note:   because the following virtual functions are pure within ‘Example’:
 class Example : public Base, public Mixin {
       ^
test.cpp:3:18: note:    virtual void Base::test()
     virtual void test() = 0;
                  ^

是否可以这样做？

我知道一个选项是让Mixin继承自Base，但在我的情况下，有几个派生类，它们不共享共同的祖先。

Answer 1

你不能直接让一个类覆盖一个不是它的基类的方法。但是你可以用迂回的方式来做。我将介绍两种方法 - 我更喜欢第二种方法。

方法1

Daniel Paul在thinkbottomup.com.au的帖子中对此进行了描述，名为C++ Mixins - Reuse through inheritance is good... when done the right way。

在你的情况下，这就是它的样子：

class Base {
public:
    virtual void test() = 0;
};

template <typename T>
class Mixin : public T {
public:
    virtual void test() override { /*... do stuff ... */ }
};

class UnmixedExample : public Base {
    /* definitions specific to the Example class _not_including_
       a definition of the test() method */
};

using Example = class Mixin<UnmixedExample>;

int main(int argc, char** argv) {
    Example{}.test();
    return 0;
}

方法2：CRTP！

CRTP是“奇怪的重复模板模式” - 如果您之前没有看到它，请务必遵循该链接。使用这种方法，我们将使用virtual继承说明符来避免歧义，与前一种方法不同 - 我们不会颠倒Mixin和Example类的继承顺序。

class Base {
public:
    virtual void test() = 0;
};

template <typename T>
class Mixin : virtual T {
public:
    virtual void test() override { /*... do stuff ... */ }
};

class Example : public virtual Base, public virtual Mixin<Base> {
    /* definitions specific to the Example class _not_including_
       a definition of the test() method */
};

int main(int argc, char** argv) {
    Example{}.test();
    return 0;
}

注意两种解决方案：

是不是很好奇CRTP如何在整个地方重复出现？： - ）
我使用的代码是用于教学目的的C ++ 11，但在C ++ 98中也是如此。

Answer 2

你不能让一个类覆盖一个不相关的类的虚函数。你可以做些不同的事情来解决这个问题。您可以将mixin设置为（几乎）从类型参数派生的模板，并将其用作class Example : public virtual Base, Mixin，或者您可以在最终类中添加代码以分派到混合：

void Derived::test() { Mixin::test(); }

如何覆盖另一个基类中的函数？

2 个答案:

方法1

方法2：CRTP！