继承方式的调整#

但是继承方式是可以调整的。

这是一个相对不常用但需要了解的技巧，主要用在 private 或 protected 继承中。我们之前学到，用 private 方式继承时，基类所有的 public 和 protected 成员在派生类中都会变成 private。但如果我就是想让其中一两个成员重新变回 public 或 protected，怎么办？

解决方法：在派生类对应的权限区（public 或 protected）中，使用 基类名::成员名; 的语法，可以“恢复”该成员的访问权限。

1
class A {
2
public:
3
    void f1(), f2(), f3();
4
protected:
5
    void g1(), g2(), g3();
6
};
7

8
class B : private A { // 采用 private 继承，A的所有成员在B中默认都是private
9
public:
10
    A::f1;  // 把原本应为 private 的 f1，权限调整回 public
11
    A::g1;  // 把原本应为 private 的 g1，权限调整为 public
12
protected:
13
    A::f2;  // 把原本应为 private 的 f2，权限调整为 protected
14
    A.g2;  // 把原本应为 private 的 g2，权限调整为 protected
15

16
// f3 和 g3 没有被提及，所以它们在 B 中仍然是 private
17
};

重要限制：你不能通过这种方式让成员的权限变得比它在基类中更宽松。比如，你不能把基类中的 protected 成员 g1 在派生类里调整为 public。

子类型关系#

“public 继承方式有着特殊的意义，它将子类型（subtype）用作基类的对外接口”。

意思就是：如果 class B 公开继承（public）了 class A，那么就意味着 B 就是一种 A。你可以把派生类当作基类来用，但反过来不行。

什么意思呢？举个例子，class B : public A，所以一个 B 对象就是一个 A 对象（并且还带有额外功能）。

合法的操作（把派生类当基类用 - Upcasting）

这就像说“一只哈士奇（派生类）可以被当作一只狗（基类）来看待”。

1. A *p = &b;
   • 含义：基类指针可以指向派生类对象。
   • 解释：你完全可以用一个“狗”的指针去指向一只“哈士奇”，这是天经地义的。
2. a = b;
   • 含义：可以将派生类对象赋值给基类对象。
   • 解释：这个操作叫做对象切片 (Slicing)。它会把 b 对象中从 A 继承来的那一部分“切”下来，拷贝给 a。b 自己独有的成员（如 int z;）会被忽略掉。就像你把一只“哈士奇”的信息登记到“狗”的档案里，你只会记录犬类共有的信息（姓名、年龄），而不会记录哈士奇独有的“拆家指数”。
3. func1(&b); func2(b); func3(b);
   • 含义：如果一个函数需要一个基类对象（或其指针/引用），你可以把一个派生类对象传给它。
   • 解释：如果一个函数需要“一只狗”，你把“一只哈士奇”传进去完全没问题。

非法的操作（把基类当派生类用 - Downcasting）

这就像说“你不能把一只普通的狗（基类）当作一只哈士奇（派生类）”，因为它不具备哈士奇的全部特征。

1. B *q = &a;
   • 含义：派生类指针不能指向基类对象。
   • 解释：你不能用“哈士奇”的指针去指向一只“普通的狗”，因为这只狗不一定有哈士奇的全部属性（比如它没有成员 z）。如果你强行这么做，然后通过指针 q 去访问 z (q->z)，程序就会出错。
2. b = a;
   • 含义：不能将基类对象赋值给派生类对象。
   • 解释：你不能把“狗”档案里的信息直接填到“哈士奇”的档案里，因为“哈士奇”档案里“拆家指数”那一栏（成员 z）该填什么呢？基类对象 a 根本没有这个数据。
3. func4(&a); func5(a); func6(a);
   • 含义：如果一个函数需要一个派生类对象，你不能把一个基类对象传给它。
   • 解释：如果一个函数明确需要“一只哈士奇”，你给它一只“普通的狗”是无法完成任务的。

构造函数#

派生类对象的初始化，是由基类和派生类共同完成的。

1. 基类的数据成员，由基类的构造函数初始化。默认情况下调用基类的默认构造函数。如果要调用基类的非默认函数，就必须在派生类的成员初始化表中指出。

   1
   class A
   2
   {
   3
       int x;
   4
   public:
   5
       A() { x = 0; }
   6
       A(int i) { x = i; }
   7
   };
   8
   class B: public A
   9
   {
   10
       int y;
   11
   public:
   12
       B()           // 将调用 A 的默认构造函数 A()
   13
       { y = 0; }
   14
       B(int i)      // 将调用 A 的默认构造函数 A()
   15
       { y = i; }
   16
       B(int i, int j):A(i) // 将调用 A 的构造函数 A(int i)
   17
       { y = j; }
   18
   };
   19
   
   20
   // ...
   21
   B b1;            // 调用 A::A() 和 B::B()，b1.x 等于 0，b1.y 等于 0
   22
   B b2(1);         // 调用 A::A(int) 和 B::B(int)，b2.x 等于 0，b2.y 等于 1
   23
   B b3(1,2);       // 调用 A::A(int) 和 B::B(int,int)，b3.x 等于 1，b3.y 等于 2
   

2. 派生类的数据成员，由派生类的构造函数初始化。

拷贝构造函数#

如果派生类没写任何拷贝构造函数。

1
// 你没有为 B 写拷贝构造函数
2
B b1( ... );
3
B b2 = b1; // 编译器自动工作

编译器知道你想干什么。你想完整地复制一个 b1 到 b2。一个完整的 B 对象包含两部分：

1. 从基类 A 继承来的部分。
2. B 自己独有的部分。

于是，智能的编译器会自动这么做：

• 对于基类 A 的部分：调用 A 的拷贝构造函数 A(const A&) 来完成拷贝。
• 对于派生类 B 的部分：逐个拷贝 B 的成员变量。

如果自己实现了拷贝构造函数。问题来了，一切都要我们自己负责。

“在任何派生类的构造函数中，如果你没有在成员初始化列表里明确地告诉我要如何初始化基类 A，那我就只能调用 A 的默认（无参）构造函数 A()。” 这个规则是铁律，它不管你当前写的是不是“拷贝构造函数”。只要你写了构造函数，就得遵守这个规则。

1
class B : public A {
2
public:
3
    // ...
4
    // 你写的“手动挡”拷贝构造函数
5
    B(const B& other) {
6
        // 函数体内部
7
        this->y = other.y; // 你只告诉了编译器如何拷贝 B 自己的成员
8
    }
9
private:
10
    int y;
11
};

这里你没有在成员初始化列表里给编译器任何关于如何处理基类 A 的指令。比如，你没有写 : A(other)。编译器遵守铁律，自动在背后调用了 A 的默认构造函数 A()。然后，才进入你的函数体，执行 this->y = other.y;。

这几乎肯定是一个BUG。A的值包没有赋值进去的。

正确的写法：

1
// 正确的、手动的拷贝构造函数
2
B(const B& other)
3
    : A(other) // <-- 在初始化列表里，明确调用基类的拷贝构造函数！
4
{
5
    this->b_val = other.b_val;
6
    std::cout << "B's CORRECT copy constructor called." << std::endl;
7
}

此时，A(other) 这里的 other (一个 B 对象) 会被自动“向上转型”为一个 A 对象，正好匹配 A 的拷贝构造函数 A(const A&)。

WARNING

铁律：自定义派生类拷贝构造函数时，永远不要忘记在成员初始化列表中调用基类的拷贝构造函数：Derived(const Derived& d) : Base(d) { ... }。

赋值运算符#

赋值运算符 operator= 的行为与构造函数不同。

• 隐式行为：如果你不写派生类的 operator=，编译器生成的版本会自动调用基类的 operator=。
• 显式行为：如果你重载了派生类的 operator=，编译器不会自动调用基类的版本，你必须手动调用。

如何手动调用？ 不能用初始化列表（它只用于构造函数）。你必须在函数体内明确调用。

1
class B : public A {
2
public:
3
    B& operator=(const B& other) {
4
        if (this == &other) { // 1. 防止自我赋值
5
            return *this;
6
        }
7

8
        // 2. 手动调用基类的赋值运算符，把基类部分搞定
9
        // A::operator=(other); 两种写法都行
10
       *(A*)this = other;
11

12
        // 3. 赋值派生类自己独有的成员
13
        // ...
14

15
        return *this; // 4. 返回*this以支持链式赋值
16
    }
17
};

不安全的析构问题#

正常是这样写代码的：

1
B* ptrB = new B();
2
delete ptrB;

在这种情况下，无论 ~A() 是不是虚函数，析构顺序永远是正确的 ~B() -> ~A()。

但是有的时候，我们会骗一下编译器：

1
A* ptrA = new B(); // 指针是 A 类型，对象是 B 类型
2
delete ptrA;

现在，当编译器看到 delete ptrA; 时，它遇到了一个决策难题。它只从表面上看到了 ptrA 是一个 A* 类型的指针。

如果~A不是虚函数。编译器会采用静态绑定。

它的“思考”过程是：“我手里的指针是 A* 类型。析构函数 ~A() 不是 virtual 的，这表示我不需要去探究这个指针背后到底藏着什么。我的任务就是调用 A* 类型对应的析构函数。”

执行结果：程序只调用了 A 的析构函数 ~A()。它根本不知道这个指针实际指向的是一个 B 对象，因此 B 的析构函数 ~B() 被完全跳过了。产生内存泄漏！

如果~A是虚函数，这时候才会正确地调用出~B，然后向上调用~A。

通过基类调用派生类独有函数#

如果派生类 B 有一个基类 A 完全没有的函数，比如 void g()，我们能通过基类指针 p 调用它吗？

1
class A { public: virtual void f(); };
2
class B : public A { public: void g(); };
3

4
A* p = new B;
5
p->g(); // 编译错误！

为什么会编译错误？ 因为编译器进行静态类型检查时，发现 p 是 A* 类型，而 class A 的定义里根本没有 g() 这个函数。编译器直接就判错了，它根本不会去想 p 将来可能会指向 B。

要想解决这个问题，我们必须把 A* 类型的指针转换成 B* 类型的指针。书上介绍了两种方法：

1）C风格的强制转换：

1
((B*)p)->g(); // 告诉编译器：“别管了，就当它是 B* 类型处理”

这样做非常危险。如果 p 恰好指向的确实是 B 对象，代码能正常工作。但如果 p 指向的是一个 A 对象呢？A 对象内存里根本没有 g() 函数，强制执行就会导致程序崩溃或出现无法预料的错误。这等于是在欺骗编译器。

2）安全的C++动态类型转换 dynamic_cast

1
B* q = dynamic_cast<B*>(p); // 尝试将 p 转换为 B*
2
if (q != nullptr) {         // 如果转换成功...
3
    q->g();                 // ...再安全地调用 g()
4
}

dynamic_cast 会在程序运行时检查 p 是否真的指向一个 B 类型的对象（或者是 B 的某个派生类）。

• 如果转换成功，它会返回一个有效的 B* 指针。
• 如果转换失败（比如 p 实际指向的是一个 A 对象），它会返回 nullptr (空指针)。

FiguresMgr 管理器#

FiguresMgr 类里有一个非常关键的成员：

1
Figure *figures[MAX_NUM_OF_FIGURES];

这是一个基类指针数组。由于 Rectangle, Circle, Line 对象都是 Figure 的一种，所以这个数组可以存放指向这三种不同类型对象的指针。它并不知道，也不关心每个位置上存的到底是什么具体形状。

函数模板#

在C++出现之前，C语言的程序员们用一种巧妙但复杂的方法来解决这个问题：void\* 通用指针。

void* 是一种“无类型”的指针，它可以指向任何类型的数据。思路如下：

1. 写一个通用的排序函数，它的参数不是 int* 或 double*，而是 void*，这样它就能接收任何类型的数组地址。
2. 因为不知道数组元素的具体类型，所以也不知道每个元素占多大内存（sizeof），也没法直接比较两个元素的大小（比如 a > b）。
3. 怎么办呢？把这两个信息也作为参数传给函数！
   • 传入每个元素的大小 element_size。
   • 传入一个比较函数的地址（函数指针 element_cmp），这个函数专门负责比较两个元素的大小。

所以，C语言版本的通用排序函数看起来非常复杂：

1
// C风格的通用排序
2
void sort(void *base, unsigned int num, unsigned int element_size,
3
          bool (*element_cmp)(const void *, const void *));

缺点：

• 非常复杂：需要手动计算内存地址，进行强制类型转换，容易出错。
• 不安全：编译器无法进行类型检查，比如你把一个比较整数的函数用在了浮点数数组上，编译时不会报错，但运行时结果就是错的。
• 调用麻烦：每次调用时，都需要提供一大堆参数，包括大小和比较函数。

C++ 提供了一种更优雅、更安全的解决方案：模板 (Template)。

你可以把模板看成是一个**“代码生成器”**。你写一个通用的函数模板，告诉编译器：“这是一个模板，请根据我调用它时使用的具体类型，自动帮我生成对应版本的函数。”

1
template <class T> // 声明这是一个模板，T 是一个通用的类型参数
2
void sort(T elements[], unsigned int num) {
3
    // ... 函数体内部可以直接使用 T 类型的变量 ...
4
    // 比如直接用 < 或 > 比较 elements[i] 和 elements[j]
5
    if (elements[i] < elements[j]) {
6
        // ...
7
    }
8
}

调用：

1
int a[100];
2
double b[200];
3

4
sort(a, 100); // 1. 编译器看到你传入了 int 类型的数组 a
5
              // 2. 它会自动用 int 替换模板里所有的 T
6
              // 3. 然后生成一个专门给 int 用的 sort 函数，就像这样：
7
              //    void sort(int elements[], unsigned int num) { ... }
8

9
sort(b, 200); // 1. 编译器看到你传入了 double 类型的数组 b
10
              // 2. 它会自动用 double 替换模板里所有的 T
11
              // 3. 然后生成一个 double 版本的 sort 函数。

这个过程叫做模板实例化 (Instantiation) 和类型推导 (Type Deduction)。编译器非常聪明，它会根据你传入的实参类型，自动推导出 T 应该是什么，然后帮你生成代码。

优点：

• 简洁：代码量大大减少，逻辑清晰。
• 安全：类型检查在编译时就完成了。如果你的类型不支持 < 比较，编译器会直接报错，而不是等到运行时才出问题。
• 高效：它没有运行时的额外开销，因为最终执行的代码和手写的特定类型版本是一样的。

如果编译器无法判断是什么类型，比如：

1
template <class T>
2
T max(T a, T b) {
3
    retrun a > b ? a : b ;
4
}
5

6
int x,y;
7
double m, n;
8
... max(x, m);  // ? 类型是什么？

就需要显式类型转换，或者显式实例化

1
... max((double)x, m);     // 显式类型转换
2
... max<double> (x, m);    // 显式实例化

也可以传入非类型参数。

类型参数 (Type Parameter)：像 class T，它是一个类型的占位符。在实例化时，它会被换成一个具体的类型，比如 int、double 或 string。

非类型参数 (Non-Type Parameter)：像 int size，它是一个常量值的占位符。在实例化时，它会被换成一个具体的、在编译时就能确定的常量值，比如 10、256。

1
template <class T, int size> // T 是类型参数，int size 是非类型参数
2
void f(T a)
3
{
4
    T temp[size]; // 关键在这里！
5
    // ...
6
}

在C++中，当你定义一个像这样的静态数组时，数组的大小（size）必须是一个在编译时就能确定的常量。你不能使用一个普通的变量来定义它的大小。

模板的作用是在编译期间生成代码。当编译器准备为 f 函数生成一个具体版本的代码时，它需要明确知道 size 到底是多少，否则 T temp[size]; 这一行就无法通过编译。

调用：

1
f<int, 10>(1);

对于这种带有非类型参数的模板，通常需要使用尖括号 < > 进行显式实例化，清楚地告诉编译器每一个参数的值。

类模板#

前面是封装函数，使得它适应不同的类型。现在是封装类。

函数模板解决了通用算法的问题，而类模板则解决了通用数据结构（如栈、队列、数组等）的问题。

1
// 关键字 class 和 typename 在这里是等价的
2
template <class T1, class T2, ...>
3
class 类名 {
4
    // ... 类成员声明 ...
5
    // 在这里面可以像使用普通类型一样使用 T1, T2
6
};

比如：

1
template <class T>
2
class Stack {
3
private:
4
    T buffer[100]; // 数据缓冲区，T 可以是 int, double 等任何类型
5
    int top;
6

7
public:
8
    Stack() { top = -1; }
9
    void push(const T &x); // 压栈的元素是 T 类型
10
    void pop(T &x);        // 出栈的元素也是 T 类型
11
};

使用：

1
Stack<int> s1;

编译器就会在后台生成一个 int 版本的 Stack 类，其中所有的 T 都被替换成了 int。

1
Stack<double> s2;

编译器则会生成一个 double 版本的 Stack 类。s1 和 s2 是两种完全不同类型的对象。

如果成员函数在类外定义，语法会稍微复杂一点，必须同时包含模板声明和类的模板参数：

1
template <class T> // 1. 模板声明不能少
2
void Stack<T>::push(const T &x) { // 2. 类名后面要带 <T>
3
    // ... 实现 ...
4
}

模板的复用#

WARNING

模板可以实现一种特殊的多态，称为参数化多态。模板是一段带有类型参数的代码，给该参数提供不同的类型就能得到多个不同的代码，即一段代码有多种解释。使用一个模板之前首先要对其进行实例化（用一个具体的类型去替代模板的类型参数），而实例化是在编译时进行的，一定要见到相应的源代码，否则无法进行实例化！因此，模板属于源代码复用。

函数模板的实例化可以是隐式的，也可以是显式的；而类模板的实例化则是显式进行的。

课本上这一块内容，主要意思就是：

模板是编译时就直接完成对应类型实现的代码实现的，如果文件中没有真正实例化，对应类型的代码不会被实现。C++编译器是先单独编译每个.cpp文件，分别生成.obj文件，最后再链接起来的。因此如果单个文件中，调用一个不是在本文件中定义的模板，会产生错误，因为模板所处的文件编译时，编译器根本不知道有这么个实例化，也就没生成对应类型实现的代码。

实现不完整，也会发生问题。

一个按照习惯会出错的地方就是这里：

1
template <class T>
2
class T {
3
public:
4
    void f();
5
};
6

7
// f.cpp
8
#include "S.h"
9
template <class T>
10
void S<T>::f() {
11
    // 具体实现...
12
}

我们习惯把具体函数的实现放在.cpp文件中，然后在main.cpp中：

1
#include "S.h"
2
int main(){
3
    S<float> s1;
4
    return 0;
5
}

这能通过编译吗？

编译器处理 main.cpp 时：

• 它通过 #include "s.h" 看到了 S 这个模板的声明。
• 当它看到 S<int> s2; 这行代码时，它知道 S<int> 是一个合法的类型，也知道它应该有一个 f() 方法。
• 但是，它没有 f() 的具体实现（因为实现在 s.cpp 里）。这时，编译器不会报错。它会想：“好的，我现在没有实现代码，但我相信别的某个 .cpp 文件会有，我就先在这里留个‘欠条’，等最后的链接阶段让链接器去把它们拼起来吧。”
• 所以，main.cpp 顺利地编译成了一个 main.obj 文件，这个文件里包含了对 S<int>::f() 的一个引用（那张“欠条”）。

编译器处理 s.cpp 时：

• 它看到了 S<T>::f() 的具体实现。
• 但是，在这个文件里，没有任何地方用到了 S<int>。
• 由于模板的“按需实例化”原则，编译器觉得既然没人用 S<int>，那它就根本不会去生成 S<int>::f() 的具体机器码。
• 所以，s.cpp 也顺利地编译成了一个 s.obj 文件，但这个文件里不包含我们需要的 S<int>::f() 的代码。

链接器 (Linker) 工作时：

• 链接器把 main.obj 和 s.obj 等所有 .obj 文件拿过来，准备把它们“粘”成一个可执行文件。
• 它看到 main.obj 里的那张“欠条”，说：“我需要 S<int>::f() 的代码，谁有？”
• 它翻遍了 s.obj 以及所有其他 .obj 文件，发现谁也没有提供这份代码。
• 这时，链接器就只能报错了：“未定义的引用 (Undefined Reference)”。

解决方案就是把模板的定义和实现都放在一个.h文件中就行了。

容器#

就是长度可变的同类型元素所构成的序列。

可以分为几类：

1. 序列容器 (Sequence Containers)：元素按顺序排列。
   • vector：动态数组。支持快速随机访问（像数组一样用 []），在尾部增删元素很快。
   • list：双向链表。支持在任意位置快速插入和删除，但随机访问很慢。
   • deque：双端队列。是 vector 和 list 的折中，支持在头部和尾部快速增删。
2. 关联容器 (Associative Containers)：元素自动排序。
   • set / multiset：集合。内部是红黑树，元素唯一且有序。multiset 允许元素重复。
   • map / multimap：映射。存储键-值对（key-value），根据 key 排序。map 的 key 唯一，multimap 允许 key 重复。
3. 容器适配器 (Container Adapters)：
   • stack：栈。后进先出 (LIFO)，通常基于 deque 实现。
   • queue：队列。先进先出 (FIFO)，通常基于 deque 实现。
   • priority_queue：优先队列。最大（或最小）的元素总是在队首，通常基于 vector 和堆 (heap) 实现。

stack, queue, priority_queue 是“适配器”，它们限制了原有容器的功能，不支持迭代器，因此你不能把它们直接用在 sort、find 等通用算法上。

如果你想在容器里存储自己写的类对象，比如 vector<Student>，那么你的 Student 类可能需要满足一些条件：

• 对于所有容器：你的类必须是可复制和可赋值的，因为容器在内部可能需要拷贝或移动元素。这意味着你需要一个正常的拷贝构造函数和赋值运算符 (operator=)。（通常编译器会为你生成默认的，但涉及指针时需小心深浅拷贝）。
• 对于关联容器（如 map, set）：因为它们需要对元素排序，所以你的类必须是可比较的。默认情况下，你需要重载小于号运算符 (operator<)。

迭代器#

迭代器是连接容器和算法的“手”或“胶水”。它的设计思想就是模仿C++中的指针，但功能更通用、

一个指针最基本的两项操作是什么？

1. 解引用（Dereferencing）：通过 * 获取指针指向的内存里的值。
2. 移动（Incrementing/Decrementing）：通过 ++ 或 -- 移动指针，让它指向下一个或上一个内存地址。

迭代器就封装了这些核心功能，并根据其能力的大小，分成了五个不同的类别。

并非所有容器都能支持所有类型的移动。比如，链表就不能像数组那样随机跳到任意一个元素，它只能一个一个地移动。为了精确描述不同容器提供的遍历能力，STL定义了五种迭代器，它们的能力是层层递进的：

这个关系就像一个能力升级树：