将叶类重构为基类，并保留它的接口实现

Question

我正在尝试重构工作代码。该代码基本上将接口类派生为工作实现，我想在原始项目之外使用此实现作为独立的类。

但是，我不想创建一个分支，我希望原始项目能够拿出他们的实现，并使用我的。问题是层次结构非常不同，我不确定这是否可行。我也无法在我的项目中使用原始基类，因为实际上它在项目中非常复杂（包含太多类），并且我只需要处理原始项目问题的子域。

我编写这段代码是为了测试如何实现它的想法，虽然它正在工作，但我不确定我喜欢它：

#include <iostream>

// Original code is:
// IBase -> Derived1

// I need to refactor Derive2 to be both indipendet class
// and programmers should also be able to use the interface class
// Derived2 -> MyClass + IBase
// MyClass


class IBase {
public:
    virtual void printMsg() = 0;
};

///////////////////////////////////////////////////
class Derived1 : public IBase {
public:
    virtual void printMsg(){ std::cout << "Hello from Derived 1" << std::endl; }
};


//////////////////////////////////////////////////
class MyClass {
public:
    virtual void printMsg(){ std::cout << "Hello from MyClass" << std::endl; }
};

class Derived2: public IBase, public MyClass{
    virtual void printMsg(){ MyClass::printMsg(); }
};

class Derived3: public MyClass, public IBase{
    virtual void printMsg(){ MyClass::printMsg(); }
};

int main()
{
    IBase *o1 = new Derived1();
    IBase *o2 = new Derived2();
    IBase *o3 = new Derived3();
    MyClass *o4 = new MyClass();

    o1->printMsg();
    o2->printMsg();
    o3->printMsg();
    o4->printMsg();

    return 0;
}

输出按预期工作（使用 gcc 和 clang 进行测试，2 个不同的 C++ 实现，所以我认为我在这里是安全的):

[elcuco@pinky ~/src/googlecode/qtedit4/tools/qtsourceview/qate/tests] ./test1
Hello from Derived 1
Hello from MyClass
Hello from MyClass
Hello from MyClass
[elcuco@pinky ~/src/googlecode/qtedit4/tools/qtsourceview/qate/tests] ./test1.clang 
Hello from Derived 1
Hello from MyClass
Hello from MyClass
Hello from MyClass

问题是

我原来的代码是：

class Derived3: public MyClass, public IBase{
    virtual void IBase::printMsg(){ MyClass::printMsg(); }
};

这就是我想要表达的内容，但这不能编译。我必须承认我并不完全理解为什么这段代码有效，因为我期望新方法 Derived3::printMsg() 将是 MyClass::printMsg() 的实现> 而不是 IBase::printMsg() （即使很难，这也是我想要的）。

当两个“姐妹类”具有相同的虚函数名称时，编译器如何选择重新实现哪个方法？

如果有人有更好的方法来实现这一点，我也想知道:)

Answer 1

答案是，编译器会覆盖两个函数，如本示例所示：

#include <cstdio>
using std::printf;

class A {
public:
    virtual void a() {
        printf("A::a\n");
    }
};
class B {
public:
    virtual void a() {
        printf("B::a\n");
    }
};
class C : public A, public B {
public:
    virtual void a() {
        printf("C::a\n");
        A::a();
        B::a();
    }
};
int main() {
    C c;
    A &a = c;
    B &b = c;
    printf("Calling C::a via A\n");
    a.a();
    printf("Calling C::a via B\n");
    b.a();
}

输出为：

Calling C::a via A
C::a
A::a
B::a
Calling C::a via B
C::a
A::a
B::a

如果您想覆盖其中一个而不是另一个，则需要重命名它。它不仅会做你想要的，而且也会更清晰。

Answer 2

编译器实际上并不选择要重写的两种方法之一。相反，它发现有两个具有相同签名的虚拟函数，并在派生类中查找该签名的重写。

如果 Derived3 没有重新实现 printMsg，那么在 Derived3 类型的对象上调用该成员将是不明确的。由于您已经重新实现了该方法，编译器可以愉快且明确地在 Derived3 类型的对象上调用该版本。