C++继承时子类需承载未使用的基类私有属性，是否必须接受？

首先，咱们先明确问题根源：你当前的继承链 C -> B -> A 是强"is-a"关系，C++的对象布局规则要求子类必须包含基类的所有成员，哪怕你完全用不上。但既然doSomeThing()和A的属性完全无关，咱们完全可以通过调整类设计来切断这个不必要的依赖，消除内存浪费。

方案1：拆分职责，用独立接口类承载doSomeThing() #

把和A无关的doSomeThing()抽成一个独立的空基类，让B同时继承这个接口类和A，而C只继承这个接口类即可：

#include <iostream>
using namespace std;

// 独立的接口类，只负责提供doSomeThing功能
class DoSomethingProvider {
public:
    void doSomeThing() {
        cout << "I am B object\n";
    }
};

class A {
private:
    int att_1;
    int att_2;
    int att_3;
public:
    A() { att_1 = att_2 = att_3 = 0; }
    int sum() { return att_1 + att_2 + att_3; }
};

// B同时拥有A的功能和doSomeThing功能
class B : public A, public DoSomethingProvider {
    // 无需额外代码，自动继承两个类的特性
};

// C只继承需要的DoSomethingProvider，完全不沾A的成员
class C : public DoSomethingProvider {
public:
    int att_4;
};

int main() {
    C obj;
    obj.doSomeThing();
    cout << sizeof(C); // 现在sizeof(C)是4字节（仅att_4，空基类被优化）
    return 0;
}

这里利用了C++的空基类优化（Empty Base Optimization, EBO）：当基类没有非静态数据成员时，子类不会为基类分配额外内存，完美解决浪费问题。

方案2：用组合代替继承（如果B不需要"A的身份"） #

如果B和A的关系不是严格的"is-a"，只是B需要用到A的sum()方法，那可以把A作为B的成员变量，而不是让B继承A。这样C继承B时，如果你不想让C包含A的实例，还可以进一步拆分B：

#include <iostream>
using namespace std;

class A {
private:
    int att_1;
    int att_2;
    int att_3;
public:
    A() { att_1 = att_2 = att_3 = 0; }
    int sum() { return att_1 + att_2 + att_3; }
};

// 只保留doSomeThing的类
class BasicB {
public:
    void doSomeThing() {
        cout << "I am B object\n";
    }
};

// 需要A功能的B，组合BasicB和A
class FullB : public BasicB {
private:
    A a_instance; // 用组合代替继承A
public:
    int sum() { return a_instance.sum(); }
};

// C只继承BasicB，完全不涉及A
class C : public BasicB {
public:
    int att_4;
};

int main() {
    C obj;
    obj.doSomeThing();
    cout << sizeof(C); // 同样是4字节
    return 0;
}

这种方式更灵活，能清晰区分"需要的功能"和"无关的依赖"。

方案3：把doSomeThing()改成静态函数（如果不需要实例状态） #

如果doSomeThing()不需要访问任何类成员变量，直接把它做成静态函数，C不需要继承任何类就能调用：

#include <iostream>
using namespace std;

class A {
private:
    int att_1;
    int att_2;
    int att_3;
public:
    A() { att_1 = att_2 = att_3 = 0; }
    int sum() { return att_1 + att_2 + att_3; }
};

class B : public A {
public:
    static void doSomeThing() { // 改成静态函数
        cout << "I am B object\n";
    }
};

class C {
public:
    int att_4;
};

int main() {
    C obj;
    B::doSomeThing(); // 直接通过类名调用
    cout << sizeof(C); // 4字节，完全无额外开销
    return 0;
}

这是最简单的方案，但只适用于函数不需要实例状态的场景。

为什么原来的设计会有开销？ #

C++的public继承语义是**"is-a"**：既然C是B，B是A，那C对象必须包含A的所有成员——这是语言的规则，保证了继承体系的多态性和正确性。但如果你的场景里没有这种"is-a"的需求，强行用继承就会带来不必要的代价。

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