C++类与继承

在 C++ 中，继承（Inheritance） 是一种面向对象编程（OOP）的核心机制，允许一个类（派生类/子类）基于另一个类（基类/父类）来构建，并继承其成员变量和成员函数。

C++ 支持三种继承方式：

1. public 继承（最常用）
2. protected 继承（较少使用）
3. private 继承（极少使用）

它们的核心区别在于 基类成员在派生类中的访问权限变化。

1. 继承的基本语法

class Base {
public:
    int publicVar;
protected:
    int protectedVar;
private:
    int privateVar;
};

// 继承方式：public/protected/private
class Derived : public Base {
    // Derived 继承 Base 的成员
};

• Derived 是派生类，Base 是基类。
• 继承方式影响 Base 的成员在 Derived 中的访问权限。

2. 三种继承方式的区别

(1) public 继承（最常用）

• 基类的 public 成员 → 在派生类仍为 public
• 基类的 protected 成员 → 在派生类仍为 protected
• 基类的 private 成员 → 在派生类不可访问（仍然属于 Base）

示例：

class Base {
public:
    int x;
protected:
    int y;
private:
    int z;
};

class Derived : public Base {
    // x 仍然是 public
    // y 仍然是 protected
    // z 不可访问
};

适用场景：

• “is-a” 关系（派生类是一种基类），例如：
  • class Student : public Person（学生是人）
  • class Car : public Vehicle（汽车是交通工具）

(2) protected 继承

• 基类的 public 成员 → 在派生类变为 protected
• 基类的 protected 成员 → 在派生类仍为 protected
• 基类的 private 成员 → 在派生类不可访问

示例：

class Base {
public:
    int x;
protected:
    int y;
private:
    int z;
};

class Derived : protected Base {
    // x 变为 protected
    // y 仍然是 protected
    // z 不可访问
};

适用场景：

• 派生类需要隐藏基类的 public 接口，使其对外不可见，仅允许派生类的子类访问。
• 实际开发中较少使用。

(3) private 继承

• 基类的 public 成员 → 在派生类变为 private
• 基类的 protected 成员 → 在派生类变为 private
• 基类的 private 成员 → 在派生类不可访问

示例：

class Base {
public:
    int x;
protected:
    int y;
private:
    int z;
};

class Derived : private Base {
    // x 变为 private
    // y 变为 private
    // z 不可访问
};

适用场景：

• “implemented-in-terms-of” 关系（派生类使用基类的实现，但不暴露基类的接口）。
• 通常 优先使用组合（composition） 替代 private 继承，除非需要访问基类的 protected 成员或重写虚函数。

3. 访问权限总结

4. 关键点总结

1. public 继承：

   • 适用于 “is-a” 关系（派生类是一种基类）。
   • 基类的 public 和 protected 成员在派生类中保持原访问权限。

2. protected 继承：

   • 基类的 public 成员在派生类中降级为 protected，仅允许派生类及其子类访问。

3. private 继承：

   • 基类的所有可访问成员在派生类中变为 private，不推荐使用，通常用组合（composition）替代。

4. private 成员：

   • 在任何继承方式下，基类的 private 成员在派生类中都 不可直接访问（只能通过基类的 public/protected 方法访问）。

5. 实际代码示例

#include <iostream>
using namespace std;

class Base {
public:
    int publicVar = 1;
protected:
    int protectedVar = 2;
private:
    int privateVar = 3;
};

// public 继承
class PublicDerived : public Base {
public:
    void print() {
        cout << publicVar << endl;      // OK (public → public)
        cout << protectedVar << endl;   // OK (protected → protected)
        // cout << privateVar << endl;  // Error: private 不可访问
    }
};

// protected 继承
class ProtectedDerived : protected Base {
public:
    void print() {
        cout << publicVar << endl;      // OK (public → protected)
        cout << protectedVar << endl;   // OK (protected → protected)
        // cout << privateVar << endl;  // Error: private 不可访问
    }
};

// private 继承
class PrivateDerived : private Base {
public:
    void print() {
        cout << publicVar << endl;      // OK (public → private)
        cout << protectedVar << endl;   // OK (protected → private)
        // cout << privateVar << endl;  // Error: private 不可访问
    }
};

int main() {
    PublicDerived pub;
    cout << pub.publicVar << endl;      // OK (public 继承后仍是 public)
    // cout << pub.protectedVar << endl; // Error: protected 不可外部访问

    ProtectedDerived prot;
    // cout << prot.publicVar << endl;   // Error: public → protected，外部不可访问

    PrivateDerived priv;
    // cout << priv.publicVar << endl;   // Error: public → private，外部不可访问

    return 0;
}

6. 结论

• 优先使用 public 继承，符合 “is-a” 关系。
• 谨慎使用 protected/private 继承，通常组合（composition）是更好的选择。
• private 成员在任何继承方式下都不可直接访问，只能通过基类提供的接口访问。

希望这个讲解能帮助你理解 C++ 继承的访问控制机制！ 🚀