C++继承详解

一、 继承的基本概念与语法

核心思想 ：将多个类共有的属性和行为提取出来，组成一个基类（父类） 。其他类通过继承这个基类成为派生类（子类），从而实现代码复用。

#include <iostream>
#include <string>
using namespace std;

// 基类 (父类)
class Person {
public:
    string name;
    int age;
};

// 派生类 (子类) 继承 Person
// 语法：class 派生类名 : 继承方式 基类名
class Student : public Person {
public:
    int student_id; // 子类特有的属性
    void study() { cout << name << " 正在学习。" << endl; } // 可以直接使用父类的 name
};

class Teacher : public Person {
public:
    string subject;
    void teach() { cout << name << " 正在教 " << subject << "。" << endl; }
};

---

二、 继承方式与访问权限限制

继承方式决定了基类成员到达派生类后，访问权限会发生怎样的"降级"。关键点正如你所说：protected 专为继承而生。

• public 成员：类内类外都能访问。

• protected 成员 ：类内、子类内可以访问，类外不能访问。

• private 成员 ：只有本类内可以访问，子类和类外都不能访问。(注：子类其实继承了父类的 private 数据，占据了内存，只是编译器不让你直接访问它)。

继承方式	基类 public 成员变成	基类 protected 成员变成	基类 private 成员变成
public 继承	public (保持不变)	protected (保持不变)	不可见 (无法直接访问)
protected 继承	protected (降级)	protected (保持不变)	不可见 (无法直接访问)
private 继承	private (降级)	private (降级)	不可见 (无法直接访问)

---

三、 构造函数与析构函数的执行顺序

核心法则 ：基类的构造和析构函数不能被继承。

• 构造顺序：先调用基类构造，再调用派生类构造。（先有父，后有子）

• 析构顺序：先调用派生类析构，再调用基类析构。（白发人送黑发人）

  #include <iostream>
  using namespace std;

  class Base {
  public:
  Base() { cout << "1. 基类 Base 构造函数" << endl; }
  ~Base() { cout << "4. 基类 Base 析构函数" << endl; }
  };

  class Derived : public Base {
  public:
  Derived() { cout << "2. 派生类 Derived 构造函数" << endl; }
  ~Derived() { cout << "3. 派生类 Derived 析构函数" << endl; }
  };

  int main() {
  cout << "--- 创建对象 ---" << endl;
  Derived d;
  cout << "--- 销毁对象 ---" << endl;
  return 0;
  }

---

四、 同名成员的处理 (隐藏机制)

当派生类和基类出现同名成员变量或同名成员函数时，派生类的成员会"隐藏"基类的同名成员。

• 访问派生类成员：直接点 对象.成员。

• 访问基类被隐藏的成员：加上基类的作用域 对象.基类名::成员。

  class BaseA {
  public:
  int num = 10;
  void print() { cout << "BaseA 的 print" << endl; }
  };

  class DerivedA : public BaseA {
  public:
  int num = 20; // 同名成员变量
  void print() { cout << "DerivedA 的 print" << endl; } // 同名成员函数
  };

  int main() {
  DerivedA obj;
  // 默认访问的是子类自己的
  cout << "子类 num = " << obj.num << endl;
  obj.print();

    // 强行访问父类被隐藏的成员
    cout << "父类 num = " << obj.BaseA::num << endl; 
    obj.BaseA::print();
    return 0;

  }

---

五、 多继承与静态成员共享

1. 多继承语法：一个派生类可以同时继承多个基类，用逗号隔开。

2. 静态成员的继承 ：无论继承多少层，派生类多少个，基类的 static 静态成员在整个继承体系中只有唯一的一份内存。父子类共享它。

#include <iostream>
using namespace std;

class Father {
public:
    static int family_wealth; // 静态成员声明
};
int Father::family_wealth = 10000; // 静态成员类外初始化

class Mother {
public:
    int genes = 1;
};

// 多继承语法
class Child : public Father, public Mother {
public:
    void spendMoney() {
        family_wealth -= 100; // 子类直接花父类的钱
    }
};

int main() {
    Child c1;
    Child c2;
    
    c1.spendMoney();
    
    // c1 改变了静态变量，c2 和 Father 看到的都会变，因为它们共享同一块内存
    cout << "Father 的财富: " << Father::family_wealth << endl; // 9900
    cout << "Child c2 看到的财富: " << c2.family_wealth << endl; // 9900
    return 0;
}