课件

12.pdf

12.1 模板

模板函数与函数模板

12.1.1 模板函数与函数模板.mp4 (74.66MB)

模板类与类模板

12.1.2 模板类与类模板.mp4 (60.39MB)

notes

代码重用技术

  • 函数
  • 类与对象
  • 继承与派生
  • 多态（函数重载、运算符重载、虚函数、纯虚函数、抽象类）
  • 泛型程序设计

泛型程序设计：通用的代码需要 不受数据类型的影响，并且可以自动适应数据类型的变化，这种程序设计类型称为 泛型程序设计。

12. 模板，命名空间与异常处理 - 图3

模板

  • 模板的类型包括：函数模板、类模板
  • 模板的声明（定义）：只能在全局，命名空间或类范围内进行。即不能在局部范围，函数内进行，比如不能在 main 函数中声明或定义一个模板。

image.png

代码重用是指在软件开发中使用现有的代码模块，以实现新的功能或模块的过程。它可以提高软件开发的效率和质量，减少重复工作和维护成本。

以下是一些常用的代码重用技术：

  1. 函数和子程序：将一些常用的功能封装在函数或子程序中，以便在不同的程序中重用。
  2. 类和对象：使用面向对象编程中的类和对象，通过继承和多态性来实现代码重用。
  3. 组件和模块：使用可重用的组件和模块来构建软件系统，这些组件和模块可以通过接口和协议进行通信。
  4. 泛型编程：使用泛型编程技术，将一些通用的算法和数据结构实现为模板，以便在不同的数据类型和程序中重用。
  5. 库和框架：使用现有的软件库和框架来加速开发过程，减少代码量和维护成本。

这些技术都可以帮助程序员在不同的应用程序中重用代码，提高开发效率和软件质量。选择哪种代码重用技术取决于具体的应用场景和需求。

模板（template）是一种泛型编程技术，它允许程序员编写通用代码，而不用关心代码将被用于什么类型。模板允许在编译时使用参数化类型，从而在编译时生成具体的代码。模板可以用于定义函数模板和类模板。

使用模板，程序员可以编写一次通用代码，然后将其用于许多不同的数据类型，从而减少了代码的冗余和维护成本，同时也提高了代码的重用性和可读性。C++ STL（标准模板库）是一个典型的例子，其中大量使用了模板技术。

模板实例化是指在使用模板时，编译器会根据实际情况将模板中的类型参数替换为具体的类型，生成对应的代码。实例化的过程可以在编译期间或运行期间进行。模板实例化的主要目的是生成可执行的代码，以便使用模板类或模板函数提供的功能。在编译期间进行实例化可以提高程序的执行效率，因为编译器可以在编译时就生成针对特定类型的优化代码。

模板参数是指在模板定义中所定义的形式参数。模板参数可以是类型参数，也可以是非类型参数。

类型参数是指可以替换为任意类型的形式参数，例如下面的模板定义中的 T 就是类型参数：

  1. template<typename T>
  2. void print(T value) {
  3.     std::cout << value << std::endl;
  4. }

非类型参数是指可以替换为任意常量表达式的形式参数，例如下面的模板定义中的 N 就是非类型参数：

  1. template<int N>
  2. int get() {
  3.     return N;
  4. }

模板参数可以用来表示模板中的类型、大小等信息，从而实现模板的通用性和灵活性。在模板实例化时，需要提供具体的模板参数，以生成特定的模板实例。

image.png

  1. #include <iostream>
  2. #include <algorithm>
  4. using namespace std;
  6. template <typename T>
  7. T max(T a, T b) {
  8.     return a > b ? a : b;
  9. }
  11. int main() {
  12.     int a = 5, b = 10;
  13.     cout << "Max of " << a << " and " << b << " is " << std::max<int>(a, b) << endl;
  14.     return 0;
  15. }
  16. /* 
  17. Max of 5 and 10 is 10
  18.  */

函数模板和模板函数都是泛型编程的重要概念，但是它们在C++中是不同的概念。

函数模板（Function Template）指的是用通用形式定义的函数，通常形式如下：

  1. template <typename T>
  2. void my_swap(T& a, T& b) {
  3.     T temp = a;
  4.     a = b;
  5.     b = temp;
  6. }

这里，T 是一个类型参数，用于指定在使用函数时要使用的具体类型。在编译期间，编译器会根据代码中的实际类型来实例化函数模板，并为每种类型生成一个相应的函数。

模板函数（Template Function）是指具体的使用函数模板生成的函数。例如，如果在代码中调用 my_swap(3, 4)，则编译器会根据这个调用生成一个类型为 int 的模板函数 my_swap，并用这个函数来执行这个调用。

因此，函数模板是一个通用的函数定义，可以根据需要生成任意类型的模板函数；而模板函数则是根据函数模板实例化生成的、具体的函数。

函数模板

⚠️ 课件中使用的 max 标识符统一替换为 my_max，使用 max 作为标识符，可能会出现一些无法预测的错误。

问题描述：
A：一个函数求两个值中的最大者。
B：针对什么数据类型求解？
A：所有基本数据类型都有可能要使用这个功能。
B：函数重载，写多个函数，功能一模一样，但数据类型不同，比如 int my_max(int x,int y){ … } float my_max(float x,float y){ … }
A：这些函数除了操作的数据类型不同之外，代码框架是一样的。这使程序代码变得累赘而加大维护难度。
B：宏定义怎样？#define my_max(x, y) ((x) > (y) ? (x) : (y))
A：解决了代码维护问题，但缺少类型检查，容易产生错误！

C++ 的模板可以轻松地解决上述问题，此时 数据类型本身就是一个参数。

  1. template<class 形参名1，class 形参名2，......> 返回类型 函数名(参数列表) {
  2.   函数体
  3. }
  1. template<class T> T my_max(T x,T y) {
  2.   return x > y ? x : y;
  3. }

my_max 代表了一类具有相同程序逻辑的函数，称为函数模板。

由函数模板实例化出的函数称为 模板函数。

函数模板必须实例化

  • 隐式实例化：当调用模板函数时，编译器会根据传入的参数类型自动推导模板参数类型并实例化模板函数，然后进行编译和链接。这个过程被称为隐式实例化。
  • 显式实例化：显式实例化是指在代码中手动指定需要实例化的模板参数类型，这样编译器就只会生成指定的模板实例，而不是对所有可能的类型都进行实例化。
  1. #include <iostream>
  3. using namespace std;
  5. template <class T> T my_max(T x, T y) { return x > y ? x : y; }
  7. int main() {
  8.     double a = 1.0, b;
  9.     b = my_max(a, 2.0); // 隐式实例化，相当于 b = my_max<double>(a, 2.0);
  10.     cout << "b = " << b << endl; // => b = 2
  11.     return 0;
  12. }
  1. #include <iostream>
  3. using namespace std;
  5. template <class T> T my_max(T x, T y) { return x > y ? x : y; }
  7. int main() {
  8.     double a = 1.0, b;
  9.     b = my_max<double>(a, 2.0); // 显式实例化
  10.     cout << "b = " << b << endl; // => b = 2
  11.     return 0;
  12. }
  • 显式实例化可以在编译时生成特定类型的函数代码，避免因为传入参数类型的差异导致的代码重复，可以提高程序的运行效率和减小程序的体积。
  • 有些编译器可能无法自动推导出函数模板的实参类型，需要手动进行实例化。

补充：即便我们将语句 b = my_max<double>(a, 2.0); 故意写成 b = my_max<int>(a, 2.0); 在有些编译器下也不会报错，程序依旧可以正常执行。这一点有个印象就好，如果能够明确知道数据类型，写上就对了，不要故意写错。

函数模板与模板函数的关系

image.png

B：函数模板实例化的时候，实例化为类类型可以吗？
A：可以！但要注意：max 模板需要比较 2 个数据的大小，您的这个类型认识 ~~`>` 运算符吗？
B：不认识，但我运算符重载 `>`，是不是就可以了？
A：是的。如果没有进行运算符重载，编译器将不能明白 `>` 运算符作用在类类型上是什么意思。重载之后就知道了！也就可以实例化并在类类型上面使用 max 函数。~~

👆🏻 课件中的这段对话是有问题的，函数模板实例化为类类型是不合法的。

  1. // 无法实例化这 2 个 max 函数！怎么解决？
  2. // 使用 my_max(int,int) 还是 my_max(char,char) 呢？
  3. void Func(int num, char ch){
  4.   int a = my_max(num, ch);
  5.   int b = my_max(ch, num);
  6. }
  1. #include <iostream>
  3. using namespace std;
  5. template <class T, class D> T my_max(T x, D y) { return (x > y) ? x : y; }
  7. int main() {
  8.     int a = 9;
  9.     char b = 34;
  10.     int rr = my_max<int>(a, b);
  11.     cout << "rr = " << rr << endl; // => rr = 34
  12.     return 0;
  13. }
  1. #include <iostream>
  3. using namespace std;
  5. template <class T> T my_max(T x, T y) { return x > y ? x : y; }
  7. int main() {
  8.     int a = 9;
  9.     char b = 34;
  10.     int rr = my_max<int>(a, b);
  11.     cout << "rr = " << rr << endl; // => rr = 34
  12.     return 0;
  13. }
  1. #include <iostream>
  3. using namespace std;
  5. template <class T> T my_max(T x, T y) {
  6.     cout << "template my_max called" << endl;
  7.     return (x > y) ? x : y;
  8. }
  10. int my_max(int x, int y) {
  11.     cout << "my_max called" << endl;
  12.     return (x > y) ? x : y;
  13. }
  15. int main() {
  16.     int num = 1;
  17.     char ch = 2;
  18.     my_max(num, num); // 调用 my_max(int, int)
  19.     my_max(ch, ch);   // 调用 my_max(T, T)
  20.     my_max(num, ch);  // 调用 my_max(int, int)
  21.     my_max(ch, num);  // 调用 my_max(int, int)
  22.     return 0;
  23. }
  24. /* 运行结果：
  25. my_max called
  26. template my_max called
  27. my_max called
  28. my_max called */

最佳匹配的优先规则：

  1. 完全匹配时，普通函数优于模板函数及模板函数的实例化版本
  2. 提升转换（如：char 和 short 转换为 int，及 float 转换为 double）
  3. 标准转换（如：int 转换为 char，及 long 转换为 double）
  4. 用户定义的转换，如类声明中定义的转换。

问题记录

  1. char my_max(char x, char y) {
  2.     cout << "char my_max called" << endl;
  3.     return (x > y) ? x : y;
  4. }

image.png

类模板

  1. #include <iostream>
  3. using namespace std;
  5. class node {
  6.   private:
  7.     int value;
  8.     node* prev;
  9.     node* next;
  11.   public:
  12.     node() {
  13.         prev = NULL;
  14.         next = NULL;
  15.     }
  16.     void setValue(int value) { this->value = value; }
  17.     void append(node* p);
  18.     void print();
  19. };
  21. void node::append(node* p) {
  22.     p->next = this->next;
  23.     p->prev = this;
  24.     if (next != NULL)
  25.         next->prev = p;
  26.     next = p;
  27. }
  29. void node::print() {
  30.     node* p = this;
  31.     while (p != NULL) {
  32.         cout << p->value << " ";
  33.         p = p->next;
  34.     }
  35.     cout << endl;
  36. }
  38. int main() {
  39.     node* list_head;
  40.     node node, node1, node2, node3, node4;
  42.     node.setValue(1);
  43.     node1.setValue(2);
  44.     node2.setValue(3);
  45.     node3.setValue(4);
  46.     node4.setValue(5);
  48.     list_head = &node;
  49.     list_head->print(); // 1
  51.     list_head->append(&node1);
  52.     list_head->print(); // 1 2
  54.     list_head->append(&node2);
  55.     list_head->print(); // 1 3 2
  57.     list_head->append(&node3);
  58.     list_head->print(); // 1 4 3 2
  60.     list_head->append(&node4);
  61.     list_head->print(); // 1 5 4 3 2
  63.     return 0;
  64. }

append 方法，用于向当前节点的后一个位置插入新成员

  1. int main() {
  2.     node* list_head;
  3.     node node, node1, node2, node3, node4;
  5.     node.setValue(1);
  6.     node1.setValue(2);
  7.     node2.setValue(3);
  8.     node3.setValue(4);
  9.     node4.setValue(5);
  11.     list_head = &node;
  12.     list_head->print(); // 1
  14.     node.append(&node1);
  15.     list_head->print(); // 1 2
  17.     node1.append(&node2);
  18.     list_head->print(); // 1 2 3
  20.     node2.append(&node3);
  21.     list_head->print(); // 1 2 3 4
  23.     node3.append(&node4);
  24.     list_head->print(); // 1 2 3 4 5
  26.     return 0;
  27. }
  1. template<class 形参名，class 形参名，…> class 类名 {
  2.   // ...
  3. };
  1. template<模板形参列表> 函数返回类型 类名<模板形参名>::函数名(参数列表) {
  2.   // ...
  3. }
  1. #include <iostream>
  3. using namespace std;
  5. template <class T> class node {
  6.     T value;
  7.     node *prev, *next;
  9.   public:
  10.     node() {
  11.         prev = NULL;
  12.         next = NULL;
  13.     }
  14.     void setValue(T value) { this->value = value; }
  15.     void append(node* p);
  16.     void print();
  17. };
  19. // node<T> 是类模板的名字
  20. template <class T> void node<T>::append(node* p) {
  21.     p->next = this->next;
  22.     p->prev = this;
  23.     if (next != NULL)
  24.         next->prev = p;
  25.     next = p;
  26. }
  28. template <class T> void node<T>::print() {
  29.     node* p = this;
  30.     while (p != NULL) {
  31.         cout << p->value << " ";
  32.         p = p->next;
  33.     }
  34.     cout << endl;
  35. }
  37. int main() {
  38.     // 用模板实参实例化模板类
  39.     node<int>* list_head;
  40.     node<int> node, node1, node2, node3, node4;
  42.     node.setValue(1);
  43.     node1.setValue(2);
  44.     node2.setValue(3);
  45.     node3.setValue(4);
  46.     node4.setValue(5);
  48.     list_head = &node;
  49.     list_head->print(); // 1
  51.     node.append(&node1);
  52.     list_head->print(); // 1 2
  54.     node1.append(&node2);
  55.     list_head->print(); // 1 2 3
  57.     node2.append(&node3);
  58.     list_head->print(); // 1 2 3 4
  60.     node3.append(&node4);
  61.     list_head->print(); // 1 2 3 4 5
  63.     return 0;
  64. }

类模板与模板类的关系

12.2 命名空间

12.2.1 命名空间.mp4 (79.95MB) image.png

C++ 中的命名空间是一种封装机制，可以帮助开发者避免名称冲突，提高代码可读性和可维护性。

命名空间是一个逻辑上的概念，用于将一组相关的函数、类、变量等封装在一个命名空间中，从而避免命名冲突。在命名空间中，每个名字都与一个特定的命名空间相关联。在不同的命名空间中，可以使用相同的名称来定义不同的实体。

C++ 中的命名空间使用 namespace 关键字来定义，例如：

  1. namespace my_namespace {
  2.     // 命名空间中的代码
  3. }

在命名空间中定义的变量、函数和类等都可以通过命名空间限定符来访问，例如：

  1. my_namespace::my_function();
  2. my_namespace::my_class obj;

还可以通过 using 关键字来引入命名空间中的名称，例如：

  1. using my_namespace::my_function;
  2. my_function();

也可以通过 using namespace 来引入整个命名空间，例如：

  1. using namespace my_namespace;
  2. my_function();
  3. my_class obj;

但是在实际开发中，为了避免命名冲突，通常不建议使用 using namespace 引入整个命名空间，而是建议使用命名空间限定符来访问。

  1. #include <iostream>
  2. using namespace std;
  3. class Student {
  4.   public:
  5.     void ShowMe() { cout << "MyStudent" << endl; }
  6. };
  1. #include <iostream>
  2. using namespace std;
  3. class Student {
  4.   public:
  5.     void ShowMe() { cout << "YourStudent" << endl; }
  6. };
  1. #include "MyStudent.cpp"
  2. #include "YourStudent.cpp"
  3. int main() {
  4.     Student s;
  5.     s.ShowMe();
  6.     return 0;
  7. }

报错：redefinition of 'Student' 重复定义 Student

  1. #include <iostream>
  2. using namespace std;
  3. namespace MyStudent {
  5. class Student {
  6.   public:
  7.     void ShowMe() { cout << "MyStudent" << endl; }
  8. };
  10. } // namespace MyStudent
  1. #include <iostream>
  2. using namespace std;
  3. namespace YourStudent {
  5. class Student {
  6.   public:
  7.     void ShowMe() { cout << "YourStudent" << endl; }
  8. };
  10. }
  1. #include "MyStudent.cpp"
  2. #include "YourStudent.cpp"
  4. int main() {
  5.     MyStudent::Student ms;
  6.     YourStudent::Student ys;
  8.     ms.ShowMe(); // => MyStudent
  9.     ys.ShowMe(); // => YourStudent
  11.     return 0;
  12. }
  • MyStudent:: 如果想要简写为 Student，那么可以加上 using namespace MyStudent; 语句，表示使用 MyStudent 命名空间中的成员。
  • YourStudent:: 如果想要简写为 Student，那么可以加上 using namespace YourStudent; 语句，表示使用 YourStudent 命名空间中的成员。

注意：如果同时写 using namespace MyStudent;、using namespace YourStudent; 这两条语句，那么还是会出现命名冲突错误，因为这两个命名空间中的成员 Student 重名了。

小结：

  • 命名空间也称为 名字空间，它是表达多个变量和多个函数组合成一个组的方法。
  • 主要是为了解决名字（用户定义的类型名、变量名、函数名）冲突的问题。
  • 一个命令空间是一个作用域，在不同名字空间中命名相同的符号代表不同的实体。
  • 命名空间可以在两个地方被定义：在 全局范围 层次或者是在另一个命名空间中被定义（这样就形成一个 嵌套名字空间），不能在函数和类的内部定义。
  • 全局命名空间是隐式声明的，存在于每个程序中，可以用作用域操作符引用全局命名空间的成员。
  • 全局命名空间是隐含的，它没有名字，可以通过使用双冒号 :: 来访问其中的实体。比如，全局变量 x 可以通过 ::x 来访问。
  1. #include <iostream>
  3. namespace ns1 {
  4.   int x = 1;
  5.   namespace ns2 {
  6.     int y = 2;
  7.   }
  8. } // namespace ns1
  10. int main() {
  11.     std::cout << ns1::x << std::endl;      // 访问 ns1 的 x
  12.     std::cout << ns1::ns2::y << std::endl; // 访问 ns1::ns2 的 y
  13.     return 0;
  14. }
  15. /* 运行结果：
  16. 1
  17. 2 */

12.3 异常处理

12.3.1 异常处理.mp4 (57.28MB) 12.3.2 异常处理.mp4 (66.51MB) 异常处理

今天是内存空间不足，昨天是硬盘文件被人移动到其他驱动器，前天是打印机未连接好！

程序崩溃！

总算解决程序老崩溃的问题了。

现在做到部分功能可以允许用户排除环境错误，继续运行程序；部分功能可以给出适当的提示信息。

引发异常

处理异常

异常引发和处理不在同一个函数

下层解决问题

上层处理各种异常

异常处理机制提供程序中错误检测与错误处理部分之间的通信。

异常存在于程序的正常功能之外，要求程序立即处理。

Try 和异常处理

  • 异常机制提供程序中 错误检测与错误处理 部分之间的通信。
  • throw 表达式：引发异常条件
  • try 块:以try开始，并以一个或多个catch结束。在try块中执行的代码所抛出的异常，常会被其中一个Catch子句处理。
  • 标准库定义的一组 异常类：用来在throw和相应的catch之间传递有关的错误信息。
  • try{statements;}
  • catch(exception expression1){statements;}
  • catch(exception expression2){statements;}
  • catch(exception expressionN){statements;}

try … catch 语句表达式如下：

  1. // Throw 表达式
  2. int test() {
  3.     sales_item item1, item2;
  4.     std::cin >> item1 >> item2;
  5.     if (item1.same_isbn(item2)) {
  6.         std::cout << item1 + item2 << std::endl;
  7.         return 0;
  8.     } else {
  9.         std::cerr << "Data must refer to same ISBN" << std::endl;
  10.         return -1;
  11.     }
  12. }
  1. // 改用 throw
  2. if (!item1.same_isbn(item2))
  3.     throw runtime_error("Data must refer to same ISBN");
  4. // ok, if we are still here the ISBNs are sam
  5. std::cout << item1 + item2 << std::endl;
  1. While(cin >> item1 >> item2) {
  2.     try {
  3.         if (item1.sameisbn(item2)) {
  4.             cout << item1 + item2 << endl;
  5.         } else
  6.             throw runtime_error("Data must refer to same ISBN");
  7.     } catch (runtime_error err) {
  8.         cout << err.what() << "\n Try Again? Enter y or n" << endl;
  9.         char c;
  10.         cin >> c;
  11.         if (cin && c == 'n')
  12.             break;
  13.     }
  14. }
  1. #include <iostream>
  2. using namespace std;
  4. void f1() {
  5.     void f2();
  6.     try {
  7.         f2();
  8.     } //调用f2()
  9.     catch (char) {
  10.         cout << "OK1!";
  11.     }
  12.     cout << "end1" << endl;
  13. }
  14. void f2() {
  15.     void f3();
  16.     try {
  17.         f3();
  18.     } // 调用 f3()
  19.     catch (int) {
  20.         cout << "Ok2!" << endl;
  21.     }
  22.     cout << "end2" << endl;
  23. }
  24. void f3() {
  25.     double a = 0;
  26.     try {
  27.         throw a;
  28.     } // 抛出 double 类型异常信息
  29.     catch (float) {
  30.         cout << "OK3!" << endl;
  31.     }
  32.     cout << "end3" << endl;
  33. } // f3()
  34. int main() {
  35.     void f1();
  36.     try {
  37.         f1();
  38.     } // 调用 f1()
  39.     catch (double) {
  40.         cout << "OK0!" << endl;
  41.     }
  42.     cout << "end0" << endl;
  43.     return 0;
  44. }
  45. /* 运行结果：
  46. OK0!
  47. end0 */
  1. OK0!(在主函数中捕获异常)
  2. end0(执行主函数中最后一个语句时的输出)
  1. #include <iostream>
  2. using namespace std;
  4. void f1() {
  5.     void f2();
  6.     try {
  7.         f2();
  8.     } //调用f2()
  9.     catch (char) {
  10.         cout << "OK1!";
  11.     }
  12.     cout << "end1" << endl;
  13. }
  14. void f2() {
  15.     void f3();
  16.     try {
  17.         f3();
  18.     } // 调用 f3()
  19.     catch (int) {
  20.         cout << "Ok2!" << endl;
  21.     }
  22.     cout << "end2" << endl;
  23. }
  24. void f3() {
  25.     double a = 0;
  26.     try {
  27.         throw a;
  28.     } // 抛出 double 类型异常信息
  29.     catch (double) {
  30.         cout << "OK3!" << endl;
  31.     }
  32.     cout << "end3" << endl;
  33. } // f3()
  34. int main() {
  35.     void f1();
  36.     try {
  37.         f1();
  38.     } // 调用 f1()
  39.     catch (double) {
  40.         cout << "OK0!" << endl;
  41.     }
  42.     cout << "end0" << endl;
  43.     return 0;
  44. }
  45. /* 运行结果：
  46. OK3!
  47. end3
  48. end2
  49. end1
  50. end0 */
  1. OK3!(在f3函数中捕获异常)
  2. end3(执行f3函数中最后一个语句时的输出)
  3. end2(执行f2函数中最后一个语句时的输出)
  4. end1(执行f1函数中最后一个语句时的输出)
  5. end0(执行主函数中最后一个语句时的输出)
  1. #include <iostream>
  2. using namespace std;
  4. void f1() {
  5.     void f2();
  6.     try {
  7.         f2();
  8.     } //调用f2()
  9.     catch (char) {
  10.         cout << "OK1!";
  11.     }
  12.     cout << "end1" << endl;
  13. }
  15. void f2() {
  16.     void f3();
  17.     try {
  18.         f3();
  19.     } // 调用 f3()
  20.     catch (int) {
  21.         cout << "Ok2!" << endl;
  22.     }
  23.     cout << "end2" << endl;
  24. }
  26. void f3() {
  27.     double a = 0;
  28.     try {
  29.         throw a;
  30.     } // 抛出 double 类型异常信息
  31.     catch (double) {
  32.         cout << "OK3!" << endl;
  33.         throw;
  34.     }
  35.     cout << "end3" << endl;
  36. } // f3()
  38. int main() {
  39.     void f1();
  40.     try {
  41.         f1();
  42.     } // 调用 f1()
  43.     catch (double) {
  44.         cout << "OK0!" << endl;
  45.     }
  46.     cout << "end0" << endl;
  47.     return 0;
  48. }
  49. /* 运行结果：
  50. OK3!
  51. OK0!
  52. end0 */
  1. OK3!(在f3函数中捕获异常)
  2. OK0!(在主函数中捕获异常)
  3. end0(执行主函数中最后一个语句时的输出)

标准异常

  • exception 头文件：最常见的异常类，类名为：exception.只通知异常，不提供更多信息。
  • stdexcept：定义了几种常见的异常类。
  • new：头文件定义了 bad_alloc 异常类型，提供因无法分配内存而由 new 抛出的异常
  • type_info：定义了 bad_cast 异常类。

预处理器、断言与调试

  1. int main()
  2. {
  3.     #ifndef NDEBUG
  4.     cerr<< "starting main" <<endl;
  5.     #endif
  6. }

这段代码使用了预处理器指令 #ifndef NDEBUG 和 #endif，它们之间的代码只有在 NDEBUG 未定义时才会编译。这个特殊的宏定义通常用于调试代码，开启宏定义后可以在编译器输出一些调试信息。在这个例子中，如果使用了调试选项编译程序，编译器会输出 starting main。如果没有开启调试选项，这段代码不会输出任何信息。

预处理器指令是指一组用于指导预处理器处理源代码的特殊指令，它们以 # 字符开头。预处理器指令不是 C++ 语句，而是在编译前由预处理器处理的指令。预处理器指令可以用于定义常量、条件编译、包含头文件等操作。

预处理器是 C++ 编译器中的一个程序，用于在编译程序之前对源代码进行处理，它可以根据程序中的指示修改、添加或删除文本。预处理器指令是预处理器所识别的命令，以 # 开头。预处理器指令告诉预处理器执行某些动作，比如包含文件、定义宏、检查程序中是否存在特定的条件等。

命令：$CC –D NDEBUG main.c

这条命令将 main.c 文件编译成可执行文件，其中的 $CC 是编译器的名称，-D NDEBUG 是指示预处理器定义了 NDEBUG 宏。在程序中使用了预处理指令 #ifndef NDEBUG，如果定义了 NDEBUG，则会跳过其中的代码块。这个机制可以在编译时决定是否打印调试信息，提高程序运行效率。

  1. __FILE__ 文件名
  2. __LINE__ 当前行号
  3. __TIME__ 文件编译时间
  4. __DATE__ 文件被编译的日期

Assert(expr)

Assert(word.size()>threshold);

只要 NDEBUG 未定义，assert 宏就求解条件表达式 expr，如果结果为 false，assert 输出信息并且终止程序的执行。如果该表达式有一个非零值，则 assert 不做任何操作。

在成品代码中，assert 不做任何工作，因此没有任何运行时代价。当然也不会引起任何运行时检查。Assert 仅用于检查确实不可能的条件，这只对程序的调试有帮助，但不能用来代替运行时的逻辑检查，也不能代替对程序可能产生的错误检测。