如何在C++菱形继承问题中仅让主路径虚继承（不改动V1代码）

以下代码因菱形继承导致foo()成员调用歧义，无法编译：

#include <iostream>

class BaseV1 {
public:
    BaseV1(int i = 0) {
        std::cout << i;
    }
    void foo() {}
};

class DataV1 : public BaseV1 {
public:
    DataV1() : BaseV1(1) {}
};


class BaseV2 : public BaseV1 {};

class DataV2 : public DataV1, public BaseV2 {};


int main() {
    DataV2().foo(); // request for member ‘foo’ is ambiguous
    return 0;
}

尝试仅将BaseV2改为虚继承BaseV1，问题仍未解决：

#include <iostream>

class BaseV1 {
public:
    BaseV1(int i = 0) {
        std::cout << i;
    }
    void foo() {}
};

class DataV1 : public BaseV1 {
public:
    DataV1() : BaseV1(1) {}
};


class BaseV2 : virtual public BaseV1 {};

class DataV2 : public DataV1, virtual public BaseV2 {};


int main() {
    DataV2().foo(); // request for member ‘foo’ is ambiguous
    return 0;
}

将DataV1改为虚继承BaseV1后代码可编译，但DataV2构造时BaseV1的输出不符合预期（打印0而非1）：

#include <iostream>

class BaseV1 {
public:
    BaseV1(int i = 0) {
        std::cout << i;
    }
    void foo() {}
};

class DataV1 : virtual public BaseV1 { // 不想改成虚继承
public:
    DataV1() : BaseV1(1) {}
};


class BaseV2 : virtual public BaseV1 {};

class DataV2 : virtual public DataV1, public BaseV2 {
public:
    DataV2() : DataV1() {}
};


int main() {
    DataV1().foo(); // 输出1，符合预期
    DataV2().foo(); // 输出0，DataV1的构造逻辑未生效
    return 0;
}

核心需求：尽量不改动DataV1继承BaseV1的路径（保持非虚继承），解决菱形继承的问题。

方法1：调用时明确指定基类版本 #

不需要修改任何继承结构，调用foo()时直接指定从哪个父类路径调用即可：

int main() {
    DataV2 d;
    d.DataV1::foo(); // 明确调用DataV1分支的foo
    // 也可以选 d.BaseV2::foo(); 按需选择
    return 0;
}

方法2：在DataV2中重写foo统一逻辑 #

在DataV2里定义自己的foo()函数，内部固定调用想要的基类版本，外部调用就不会有歧义：

class DataV2 : public DataV1, public BaseV2 {
public:
    void foo() {
        DataV1::foo(); // 固定转发到DataV1的foo，也可以选BaseV2的
    }
};

int main() {
    DataV2().foo(); // 无歧义，调用DataV2封装后的版本
    return 0;
}

方法3：单实例BaseV1且保留DataV1非虚继承 #

如果希望BaseV1在DataV2中只有一个实例，同时保持DataV1非虚继承，可以让BaseV2虚继承BaseV1，然后在DataV2的构造函数里显式初始化BaseV1：

#include <iostream>

class BaseV1 {
public:
    BaseV1(int i = 0) {
        std::cout << i;
    }
    void foo() {}
};

class DataV1 : public BaseV1 { // 保持非虚继承
public:
    DataV1() : BaseV1(1) {}
};

class BaseV2 : virtual public BaseV1 {}; // BaseV2虚继承BaseV1

class DataV2 : public DataV1, public BaseV2 {
public:
    DataV2() : BaseV1(1), DataV1() {} // 显式初始化虚基类BaseV1为1
};

int main() {
    DataV1().foo(); // 输出1，符合预期
    DataV2().foo(); // 输出1，BaseV1仅初始化一次，foo调用无歧义
    return 0;
}

注：虚基类的构造由最派生类（DataV2）负责，所以这里显式指定BaseV1(1)会覆盖DataV1构造里的初始化，保证输出符合预期。

内容的提问来源于stack exchange，提问作者bers