C++：如何在父类中定义子类以限制中间类访问范围

这是个很常见的代码复用+访问控制需求，刚好可以用C++的protected嵌套类来完美解决，完全符合你“在父类中定义子类”的要求。我给你一步步拆解并附上代码示例：

核心思路 #

把实现部分纯虚方法的中间类，定义为抽象父类的protected嵌套类。这样：

• 外部代码完全看不到这个中间类（因为protected成员只能被类自身及其子类访问）
• 只有抽象父类的子类（也就是你说的“相关最终子类”）能继承这个中间类，复用它的代码
• 中间类本身继承抽象父类，实现部分纯虚方法，剩下的留给最终子类完成

代码示例 #

#include <iostream>

// 抽象父类
class AbstractBase {
protected:
    // 中间类：仅AbstractBase的子类能访问
    class PartialImplementation : public AbstractBase {
    public:
        // 实现父类的部分纯虚方法
        void commonMethod1() override {
            std::cout << "PartialImplementation: 实现通用的commonMethod1" << std::endl;
        }

        // 保留另一个纯虚方法，留给最终子类实现
        // void specificMethod() override = 0;
    };

public:
    // 抽象父类的纯虚方法
    virtual void commonMethod1() = 0;
    virtual void specificMethod() = 0;

    virtual ~AbstractBase() = default;
};

// 最终子类1：继承中间类，复用代码
class ConcreteSubclassA : public AbstractBase::PartialImplementation {
public:
    void specificMethod() override {
        std::cout << "ConcreteSubclassA: 实现专属的specificMethod" << std::endl;
    }
};

// 最终子类2：同样继承中间类
class ConcreteSubclassB : public AbstractBase::PartialImplementation {
public:
    void specificMethod() override {
        std::cout << "ConcreteSubclassB: 实现专属的specificMethod" << std::endl;
    }
};

// 外部代码测试
int main() {
    AbstractBase* objA = new ConcreteSubclassA();
    objA->commonMethod1();
    objA->specificMethod();

    AbstractBase* objB = new ConcreteSubclassB();
    objB->commonMethod1();
    objB->specificMethod();

    // 下面这行代码会编译错误：因为PartialImplementation是protected的，外部无法访问
    // AbstractBase::PartialImplementation* invalid = new AbstractBase::PartialImplementation();

    delete objA;
    delete objB;
    return 0;
}

关键细节说明 #

• 访问控制：PartialImplementation被放在AbstractBase的protected区段，所以只有AbstractBase本身和它的子类（比如ConcreteSubclassA、ConcreteSubclassB）能看到并继承这个中间类，外部代码完全无法直接使用它。
• 代码复用：中间类实现了commonMethod1，所有继承它的最终子类都自动拥有这个实现，不用重复编写。
• 抽象性保留：中间类可以保留未实现的纯虚方法（比如specificMethod），确保它本身还是抽象类，不能被实例化，只能作为基类被最终子类继承。
• 多态支持：最终子类继承中间类后，仍然是AbstractBase的子类，可以通过AbstractBase的指针/引用实现多态，完全符合你的项目设计需求。

为什么不选其他方式？ #

• 如果把中间类放在全局作用域并设为private：C++不允许全局private类，而且无法限制只有特定子类能访问。
• 如果用友元：需要给每个最终子类都加友元声明，扩展性差，一旦新增子类就要修改父类代码，违反开闭原则。
• 而protected嵌套类既满足了“在父类中定义”的要求，又天然实现了访问限制，还能完美支持代码复用和多态。

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