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
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;
}

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

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

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

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

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

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

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

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

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

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