继承
需要预先学习：
1. 继承
继承（inheritance）让一个新类可以获得另一个类的成员，从而复用代码，并表达"是一种"（is-a）的关系。
学生、教师都是人，都有姓名、年龄，都会打招呼。把这些共性提取到 Person 类里，让 Student、Teacher 从它继承，各自只需写独有的部分——不必把姓名、年龄在每个类里重复一遍。
- 基类（base class，也叫父类）：被继承的类
- 派生类（derived class，也叫子类）：继承别人的类
“学生是一个人”——这种 is-a 关系是继承的核心：派生类对象可以当作基类对象来用。
1.1 继承的语法
继承写在类名后面的冒号处：
class Student : public Person // Student 公开继承 Person
{
// 这里只需写 Student 独有的成员
};#include <iostream>
#include <string>
class Person
{
public:
std::string m_name;
int m_age = 0;
void say_hello() { std::cout << "你好，我是" << m_name << std::endl; }
};
class Student : public Person
{
public:
std::string m_school;
};
int main()
{
Student s;
s.m_name = "张三"; // 继承自 Person 的成员变量
s.m_age = 15;
s.m_school = "第一中学"; // Student 自己的成员变量
s.say_hello(); // 继承自 Person 的成员函数
std::cout << "就读于" << s.m_school << std::endl;
return 0;
}编译并运行代码后，看到这样的输出：
你好，我是张三
就读于第一中学Student 的对象同时拥有 Person 的成员和 Student 自己的成员，可以直接使用继承来的成员，就像它们本来就属于 Student 一样。
1.2 继承方式与访问权限
继承时同样要写一个访问权限限定符，它决定基类成员在派生类中的访问权限：
| 基类成员 | public 继承 |
protected 继承 |
private 继承 |
|---|---|---|---|
public |
仍是 public |
变为 protected |
变为 private |
protected |
仍是 protected |
仍是 protected |
变为 private |
private |
不可直接访问 | 不可直接访问 | 不可直接访问 |
- 无论哪种继承方式，基类的
private成员在派生类中都不可直接访问——但它们仍然存在于派生类对象里，只是必须通过基类的公开接口间接使用 public继承最常用，也最符合 is-a 的语义；protected、private继承较少使用，本章只以public继承为主
protected 与 private 的区别
在 封装 里两者看起来一样（类外部都不可访问），差别在于派生类：
private：只有本类的成员函数能访问protected：本类和派生类的成员函数都能访问
#include <iostream>
#include <string>
class Animal
{
public:
void eat() { std::cout << "吃东西" << std::endl; }
protected:
std::string m_kind = "动物"; // 派生类可以访问
private:
int m_weight = 10; // 派生类也不可访问
};
class Dog : public Animal
{
public:
void show()
{
std::cout << "我是一只" << m_kind << std::endl; // protected 成员，派生类可以访问
std::cout << m_weight << std::endl; // 错误！private 成员，派生类不可访问
}
};
int main()
{
Dog d;
d.show();
return 0;
}编译时报错：
error: 'int Animal::m_weight' is private within this context所以设计基类时，把"希望派生类直接使用、但不希望外界碰"的成员声明为 protected；只希望本类自己使用的成员声明为 private。
1.3 继承中的构造函数与析构函数
派生类对象在创建时，会先构造其中的基类部分，再构造派生类自己的部分——就像盖楼先打地基、再建上层。销毁时的顺序正好相反。
#include <iostream>
#include <string>
class Person
{
public:
Person(const std::string& name) : m_name(name)
{
std::cout << "Person 构造: " << m_name << std::endl;
}
~Person()
{
std::cout << "Person 析构: " << m_name << std::endl;
}
private:
std::string m_name;
};
class Student : public Person
{
public:
Student(const std::string& name, const std::string& school)
: Person(name), m_school(school) // 在初始化列表中调用基类构造函数
{
std::cout << "Student 构造: " << m_school << std::endl;
}
~Student()
{
std::cout << "Student 析构: " << m_school << std::endl;
}
private:
std::string m_school;
};
int main()
{
Student s("张三", "第一中学");
return 0;
}编译并运行代码后，看到这样的输出：
Person 构造: 张三
Student 构造: 第一中学
Student 析构: 第一中学
Person 析构: 张三规则：
- 创建：先基类构造函数，后派生类构造函数；销毁：先派生类析构函数，后基类析构函数
- 派生类构造函数可以在初始化列表中调用基类构造函数，把参数传过去
- 如果基类没有默认构造函数，派生类构造函数必须显式调用基类的某个构造函数，否则编译报错
- 派生类不继承基类的构造函数；如果不显式写，编译器会自动生成一个默认构造函数，它先调用基类的默认构造函数
1.4 名字隐藏
如果派生类定义了与基类同名的函数，基类的所有同名重载都会被隐藏（name hiding）——即使参数列表不同：
#include <iostream>
class Base
{
public:
void func() { std::cout << "Base::func()" << std::endl; }
void func(int) { std::cout << "Base::func(int)" << std::endl; }
};
class Derived : public Base
{
public:
void func() { std::cout << "Derived::func()" << std::endl; }
};
int main()
{
Derived d;
d.func();
d.func(1); // 错误！Base 的 func(int) 被隐藏了
return 0;
}编译时报错：
error: no matching function for call to 'Derived::func(int)'编译器在派生类里找到 func 这个名字后就不再向上查找，于是基类的重载统统看不见了。有两种解决办法：
- 用类名限定调用：
d.Base::func(1); - 在派生类里用
using Base::func;把基类的所有同名重载都引入进来
1.5 派生类对象的内存布局
派生类对象在内存中，先存放基类部分（基类子对象），再存放派生类新增的成员：
Student 对象的内存布局
+------------------------+
| Person 部分 | 基类子对象：m_name、m_age
+------------------------+
| m_school | Student 新增成员
+------------------------+把派生类对象的地址赋给基类指针时，指针指向的正是最前面这段基类子对象。这个布局在 多态 里讨论虚函数表时还会用到。
相关推荐
2026-07-22
引用与左右值
引用 引用（Reference） 是一个已存在变量的别名，它提供了一种更方便的方式来间接访问变量，语法为类型 &别名 = 变量名;: int num = 10; int& ref = num; // ref 是变量 num 的别名 引用的注意事项 1. 引用必须在定义的时候初始化。 int& ref; // 错误操作 2. 引用不能再绑定其它变量。 int num1 = 10, num2 = 20; int& ref = num1; ref = num2; // 这个操作是把 num2 的值赋给 num1，而不是让ref成为num2的引用 常引用 常引用（Const Reference） 是指向常量的引用，使用const关键字修饰，语法为const 类型 &常引用名 = 变量名/常量名。 int num = 10; const int& const_ref = num; 即使常引用指向的是变量，也不允许通过引用对其进行修改。 左值与右值 左值 左值（lvalue）：具有持久内存地...
2026-07-21
内存基础
进制 在基数为 R 的进制中,包含 R 个数字符号, 分别是 0, 1, 2, …, R-1 一个整数n位、小数m位的R进制数字，可以表示为： (N)R=(Kn−1Kn−2...K0.K−1K−2...K−m)R(N)_{R} = (K_{n-1} K_{n-2} ... K_0.K_{-1}K_{-2}...K_{-m})_{R} (N)R=(Kn−1Kn−2...K0.K−1K−2...K−m)R 其中，KiK_iKi 是第 iii 位上的数字符号，满足 0≤Ki<R0 \leq K_i < R0≤Ki<R。 同时，也可以用连加符号来表示： (N)R=∑i=−mn−1KiRi(N)_{R} = \sum_{i=-m}^{n-1} K_i R^i (N)R=i=−m∑n−1KiRi 二进制 二进制是基数为 2 的进制系统，使用两个数字符号：0 和 1。每一位上的权重是 2 的幂次方。 如： (1101)2=1∗23+1∗22+0∗21+1∗20=8+4+0+1=(13)10(1101)_2 = 1 * 2^3 + 1 * 2^2 ...
2026-07-26
引用与指针的区别
需要预先学习： 指针 指针常量与常量指针 引用与左右值 语法层面 指针的值是地址，需要通过解引用操作符*来访问指针所指向的对象，而引用是一个已存在变量的别名，可以直接使用引用名来访问变量。 int num = 10; int* ptr = # int& ref = num; std::cout << *ptr << std::endl; std::cout << ref << std::endl; 资源持有层面 引用天然地不支持更换对象，而指针需要在*后加const修饰才能实现类似语义： int& ref = num; // ref 永远绑定 num ref = num2; // 这是把 num2 的值赋给 num，而不是让 ref 绑定 num2 // 相当于: int* const ptr = # // ptr 永远指向 num 内存层面 引用在一些实现中不占用额外的内存空间，而指针是一个变量，会占用一定的...
2026-09-03
多线程编程基础
基础概念 多线程编程之前，先搞清楚几个基本概念：并发、并行、进程、线程、协程。它们经常被混用，但含义差别很大，而且这些差异最终都落在硬件层面。 并发与并行 并发（concurrency）指多个任务在同一时间段内交替推进——宏观上看它们"同时"在进行，微观上可能只有一个执行单元在轮流处理。并行（parallelism）指多个任务在同一时刻真正同时执行，这要求有多个执行单元（多个 CPU 核心）。 两者的关系可以用一个经典表述概括：并发是程序结构层面的性质，并行是执行层面的性质。一个程序可以设计成并发的（多个任务交替推进），但只有在多核机器上运行时才可能并行。 单核并发（时间片轮流）： CPU 核心: [任务A][任务B][任务A][任务B][任务A][任务B] ... └── 每个时刻只有 1 个任务在跑 ──┘ 双核并行： 核心 1: [任务A][任务A][任务A][任务A] ... 核心 2: [任务B][任务B][任务B][任务B] ... └── 同一时刻有 2 个任务在跑 ──┘ 注意：并发程序...
2026-07-27
switch-case 语句
需要预先学习： if 语句 switch-case 语句 switch-case 语句是一种多分支选择结构，它根据一个整型表达式的值跳转到匹配的 case 标签处执行。基本语法如下： switch (表达式) { case 常量1: // 匹配常量1时执行的代码 break; case 常量2: // 匹配常量2时执行的代码 break; default: // 没有任何 case 匹配时执行的代码 break; } switch 后面括号中的表达式必须是整型（int、char、enum 等），case 后面必须是常量表达式。程序会拿表达式的值依次与每个 case 的值比较，找到匹配的就跳过去执行；如果没有任何匹配，就执行 default（如果有的话）。 break 的用法 break 语句用于跳出 switch 结构。如果没有 break，程序会继续执行下一个 case 中的代码——这个特性被称为"穿透"（fall-through）。 有 break 的情况（正常行为）： i...
2026-08-31
类的内存占用
需要预先了解： 类与对象 内存基础 多态 类的实例的内存占用 类的实例（对象）的内存占用，指的是 sizeof(类名) 的结果——它只统计数据成员和编译器为支持语言特性而插入的隐藏成员（如虚表指针），不包含静态成员变量和成员函数。先看一组真实测量（64 位平台）： #include <cstdio> class Empty {}; // 空类 class WithInt { public: int x; }; class WithVirt { public: virtual void f() {} int x; }; class WithStatic { public: static int s; // 静态成员变量 int x; }; int WithStatic::s = 0; int main() { prin...
