多重继承下能否从其他基类继承纯虚函数的实现？

默认情况下，你没法直接从另一非虚基类继承抽象函数的实现——像你示例里的代码，C同时继承A和B，但B::foo不会被自动当作A中纯虚foo的实现，编译器会判定C仍是抽象类，无法实例化，必须手动写转发函数才能编译通过。

针对你需要批量组合多个A类（数据操作类）和多个B类（实现类）的场景，有几种可行的方案：

1. 模板中间类自动生成转发 #

用模板类作为中间层，把提供实现的B类作为模板参数，在模板类里统一实现A的纯虚函数，自动转发到B的实现。这样每次组合新的A和B时，只需要用模板类实例化，不用重复写转发代码。

示例代码：

#include <iostream>

// 数据操作基类A
class A {
public:
    virtual void foo() = 0;
    
    void bar() {
        foo();
        foo();
        foo();
    }
};

// 实现类B
class B {
public:
    void foo() {
        std::cout << "It works!\n";
    }
};

// 另一个数据操作基类A2
class A2 {
public:
    virtual void foo() = 0;
    
    void baz() {
        foo();
    }
};

// 另一个实现类B2
class B2 {
public:
    void foo() {
        std::cout << "Another implementation!\n";
    }
};

// 通用模板中间类，适配任意A类和实现类Impl
template <typename Base, typename Impl>
class BaseWithImpl : public Base, public Impl {
public:
    void foo() override {
        Impl::foo();
    }
};

// 组合A和B
using C = BaseWithImpl<A, B>;
// 组合A2和B2
using C2 = BaseWithImpl<A2, B2>;
// 组合A和B2
using C3 = BaseWithImpl<A, B2>;

int main()
{
    C c;
    c.foo();
    c.bar();

    C2 c2;
    c2.foo();
    c2.baz();

    C3 c3;
    c3.foo();
    c3.bar();

    return 0;
}

这个方案的优势是完全复用转发逻辑，新增组合时只需要一行using声明，适合大量A和B的组合场景。

2. 让实现类继承对应的抽象基类 #

如果每个B类只对应特定的A类，可以让B直接继承A并实现foo，这样C只需要继承B就能自动拥有foo的实现。

示例代码：

#include <iostream>

class A {
public:
    virtual void foo() = 0;
    
    void bar() {
        foo();
        foo();
        foo();
    }
};

// B直接继承A并实现foo
class B : public A {
public:
    void foo() override {
        std::cout << "It works!\n";
    }
};

// C只需要继承B
class C : public B {};

int main()
{
    C c;
    c.foo();
    c.bar();

    return 0;
}

但这个方案灵活性较差，当同一个B需要适配多个不同的A类时，就需要为每个A写对应的B子类，会产生冗余代码。

3. C++20概念约束（可选） #

如果使用C++20及以上，可以用concept约束实现类必须拥有foo函数，让模板中间类更安全：

#include <iostream>
#include <concepts>

// 定义concept，要求Impl有foo函数
template <typename T>
concept HasFoo = requires(T t) {
    { t.foo() } -> std::same_as<void>;
};

class A {
public:
    virtual void foo() = 0;
    
    void bar() {
        foo();
        foo();
        foo();
    }
};

class B {
public:
    void foo() {
        std::cout << "It works!\n";
    }
};

template <typename Base, HasFoo Impl>
class BaseWithImpl : public Base, public Impl {
public:
    void foo() override {
        Impl::foo();
    }
};

using C = BaseWithImpl<A, B>;

int main()
{
    C c;
    c.foo();
    c.bar();

    return 0;
}

这样如果传入的Impl没有foo函数，编译器会直接报错，提前发现问题。

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