c++ - 将叶类重构为基类，同时保留它的接口(interface)实现

Question

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

但是，我不想创建一个分支，我希望原始项目能够取出他们的实现，并使用我的。问题是层次结构非常不同，我不确定这是否可行。我也不能在我的项目中使用原始基类，因为实际上它与项目纠缠不清(太多类，包括)，我只需要处理原始项目问题的一个子域。

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

#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

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