## C++是什么

**C++ 是一种静态类型的、编译式的、通用的、大小写敏感的、不规则的编程语言，支持过程化编程、面向对象编程和泛型编程。**

**C++ 被认为是一种中级语言，它综合了高级语言和低级语言的特点。**

**C++ 是 C 的一个超集，事实上，任何合法的 C 程序都是合法的 C++ 程序。**    

**注意：使用静态类型的编程语言是在编译时执行类型检查，而不是在运行时执行类型检查。**

### 面向对象程序设计——结构化编程

**C++ 完全支持面向对象的程序设计，包括面向对象开发的四大特性：**

- **封装（Encapsulation）：封装是将数据和方法组合在一起，对外部隐藏实现细节，只公开对外提供的接口。这样可以提高安全性、可靠性和灵活性。**
- **继承（Inheritance）：继承是从已有类中派生出新类，新类具有已有类的属性和方法，并且可以扩展或修改这些属性和方法。这样可以提高代码的复用性和可扩展性。**
- **多态（Polymorphism）：多态是指同一种操作作用于不同的对象，可以有不同的解释和实现。它可以通过接口或继承实现，可以提高代码的灵活性和可读性。**
- **抽象（Abstraction）：抽象是从具体的实例中提取共同的特征，形成抽象类或接口，以便于代码的复用和扩展。抽象类和接口可以让程序员专注于高层次的设计和业务逻辑，而不必关注底层的实现细节。**

### 标准库

**标准的 C++ 由三个重要部分组成：**

- **核心语言，提供了所有构件块，包括变量、数据类型和常量，等等。**
- **C++ 标准库，提供了大量的函数，用于操作文件、字符串等。**
- **标准模板库（STL），提供了大量的方法，用于操作数据结构等。**

**C++ 程序可以定义为对象的集合，这些对象通过调用彼此的方法进行交互。现在让我们简要地看一下什么是类、对象，方法、即时变量。**

- **对象 - 对象具有状态和行为。对象是类的实例。**
- **类 - 类可以定义为描述对象行为/状态的模板/蓝图。**
- **方法 - 从基本上说，一个方法表示一种行为。一个类可以包含多个方法。可以在方法中写入逻辑、操作数据以及执行所有的动作。**
- **即时变量 - 每个对象都有其独特的即时变量。对象的状态是由这些即时变量的值创建的。**

### C++和Python区别——基本类型or类？

| **特性**               | **C**                 | **C++**                    | **Python**              |
| ---------------------- | --------------------- | -------------------------- | ----------------------- |
| **int/double等类型**   | **基本类型**          | **基本类型**               | **类（对象）**          |
| **是否有成员函数**     | **❌ 否**              | **❌ 基本类型否，类类型有** | **✅ 是（如x.real）**    |
| **类型本身是否为对象** | **❌ 否**              | **❌ 否**                   | **✅ 是（type(x)）**     |
| **类型**               | **C语言**             | **C++**                    | **Python**              |
| **字符串**             | **char[]（非类）**    | **std::string（类）**      | **str类（一切皆对象）** |
| **布尔值**             | **_Bool/int（非类）** | **bool（基本类型，非类）** | **bool类（int的子类）** |

 

- **Python：一切皆对象，通过类统一接口，牺牲性能换取灵活性和简洁性。**

 

### 标识符

**标识符是用来标识变量、函数、类、模块，或任何其他用户自定义项目的名称。一个标识符以字母 A-Z 或 a-z 或下划线 _ 开始，后跟零个或多个字母、下划线和数字（0-9）。**

**C++ 标识符内不允许出现标点字符，比如 @、& 和 %。C++ 是区分大小写的编程语言。保留字不能作为常量名、变量名或其他标识符名称。**

### 基本的内置类型

**C++ 为程序员提供了种类丰富的内置数据类型和用户自定义的数据类型。下表列出了七种基本的 C++ 数据类型：**

| **类型**     | **关键字**  |
| ------------ | ----------- |
| **布尔型**   | **bool**    |
| **字符型**   | **char**    |
| **整型**     | **int**     |
| **浮点型**   | **float**   |
| **双浮点型** | **double**  |
| **无类型**   | **void**    |
| **宽字符型** | **wchar_t** |

**C++ 修饰符类型**

**C++ 允许在 char、int 和 double 数据类型前放置修饰符。**

**修饰符是用于改变变量类型的行为的关键字，它更能满足各种情境的需求。**

**一些基本类型可以使用一个或多个类型修饰符进行修饰**

**如前四种**

**C++ 中的类型限定符**

**类型限定符提供了变量的额外信息，用于在定义变量或函数时改变它们的默认行为的关键字。**

**后五种**

| **修饰符**   | **描述**                                                     | **示例**                  |
| ------------ | ------------------------------------------------------------ | ------------------------- |
| **signed**   | **表示有符号类型（默认）**                                   | **signed  int x = -10;**  |
| **unsigned** | **表示无符号类型**                                           | **unsigned  int y = 10;** |
| **short**    | **表示短整型**                                               | **short  int z = 100;**   |
| **long**     | **表示长整型**                                               | **long  int a = 100000;** |
| **const**    | **表示常量，值不可修改**                                     | **const  int b = 5;**     |
| **volatile** | **表示变量可能被意外修改，禁止编译器优化**                   | **volatile  int c = 10;** |
| **mutable**  | **表示类成员可以在 const 对象中修改**                        | **mutable  int counter;** |
| **restrict** | **由 restrict 修饰的指针是唯一一种访问它所指向的对象的方式。只有 C99 增加了新的类型限定符 restrict。** |                           |
| **static**   | **用于定义静态变量，表示该变量的作用域仅限于当前文件或当前函数内，不会被其他文件或函数访问。** |                           |

 

 

**C++11 新增类型**

| **数据类型**              | **描述**                               | **示例**                                          |
| ------------------------- | -------------------------------------- | ------------------------------------------------- |
| **auto**                  | **自动类型推断**                       | **auto  x = 10;**                                 |
| **decltype**              | **获取表达式的类型**                   | **decltype(x)  y = 20;**                          |
| **nullptr**               | **空指针常量**                         | **int\*  ptr = nullptr;**                         |
| **std::initializer_list** | **初始化列表类型**                     | **std::initializer_list<int>  list = {1, 2, 3};** |
| **std::tuple**            | **元组类型，可以存储多个不同类型的值** | **std::tuple<int,  float, char> t(1, 2.0, 'a');** |

**派生数据类型**

| **数据类型**      | **描述**                                           | **示例**                              |
| ----------------- | -------------------------------------------------- | ------------------------------------- |
| **数组**          | **相同类型元素的集合**                             | **int  arr[5] = {1, 2, 3, 4, 5};**    |
| **指针**          | **存储变量内存地址的类型**                         | **int\*  ptr = &x;**                  |
| **引用**          | **变量的别名**                                     | **int&  ref = x;**                    |
| **函数**          | **函数类型，表示函数的签名**                       | **int  func(int a, int b);**          |
| **结构体**        | **用户定义的数据类型，可以包含多个不同类型的成员** | **struct  Point { int x; int y; };**  |
| **类**            | **用户定义的数据类型，支持封装、继承和多态**       | **class  MyClass { ... };**           |
| **联合体/共用体** | **多个成员共享同一块内存**                         | **union  Data { int i; float f; };**  |
| **枚举**          | **用户定义的整数常量集合**                         | **enum  Color { RED, GREEN, BLUE };** |

**类型别名**

| **别名**    | **描述**                             | **示例**                |
| ----------- | ------------------------------------ | ----------------------- |
| **typedef** | **为现有类型定义别名**               | **typedef  int MyInt;** |
| **using**   | **为现有类型定义别名（C++11 引入）** | **using  MyInt = int;** |

**标准库类型**

| **数据类型**    | **描述**                       | **示例**                               |
| --------------- | ------------------------------ | -------------------------------------- |
| **std::string** | **字符串类型**                 | **std::string  s = "Hello";**          |
| **std::vector** | **动态数组**                   | **std::vector<int>  v = {1, 2, 3};**   |
| **std::array**  | **固定大小数组（C++11 引入）** | **std::array<int,  3> a = {1, 2, 3};** |
| **std::pair**   | **存储两个值的容器**           | **std::pair<int,  float> p(1, 2.0);**  |
| **std::map**    | **键值对容器**                 | **std::map<int,  std::string> m;**     |
| **std::set**    | **唯一值集合**                 | **std::set<int>  s = {1, 2, 3};**      |

 

 

| **方式**       | **类型安全** | **可读性** | **标准一致性** |
| -------------- | ------------ | ---------- | -------------- |
| **true/false** | **✅ 最佳**   | **✅ 最佳** | **✅ C++标准**  |
| **隐式判断**   | **✅ 好**     | **✅ 简洁** | **✅ 推荐**     |
| **1/0**        | **❌ 弱**     | **❌ 差**   | **⚠️ C遗留**    |
| **TRUE/FALSE** | **⚠️ 依赖宏** | **❌ 过时** | **⚠️ 兼容C**    |

 

### typedef 声明

**您可以使用 typedef 为一个已有的类型取一个新的名字。下面是使用 typedef 定义一个新类型的语法：**

**typedef type newname;** 

### 枚举类型(enumeration)

**是C++中的一种派生数据类型，它是由用户定义的若干枚举常量的集合。**

**如果一个变量只有几种可能的值，可以定义为枚举(enumeration)类型。所谓"枚举"是指将变量的值一一列举出来，变量的值只能在列举出来的值的范围内。**

**创建枚举，需要使用关键字 enum。枚举类型的一般形式为：**

**enum 枚举名{** 

   **标识符[=整型常数],** 

   **标识符[=整型常数],** 

**...** 

  **标识符[=整型常数]**

**} 枚举变量;**

  

**如果枚举没有初始化, 即省掉"=整型常数"时, 则从第一个标识符开始。**

**例如，下面的代码定义了一个颜色枚举，变量 c 的类型为 color。最后，c 被赋值为 "blue"。**

**enum color { red, green, blue } c;**

**c = blue;**

**1. c 的类型是什么？**

**c 的类型是 enum color（C语言）**

**2. red/green/blue 是什么类型？**

**它们是整型常量（int），不是字符串**

**类型转换**

**类型转换是将一个数据类型的值转换为另一种数据类型的值。**

**C++ 中有四种类型转换：静态转换、动态转换、常量转换和重新解释转换。**

**3、**

**enum color 的底层是整数类型（通常是 int）
 虽然 c 的类型名义上是 enum color，但它的存储方式和操作完全按照整数处理：**

**printf("%d", c); \*//\* 输出 2（blue 的值）**

**枚举值（red/green/blue）本质是编译时的整型常量（red=0, green=1, blue=2）。**

### 函数

 

函数是一组一起执行一个任务的语句。每个 C++ 程序都至少有一个函数，即主函数 main() ，所有简单的程序都可以定义其他额外的函数。

 

您可以把代码划分到不同的函数中。如何划分代码到不同的函数中是由您来决定的，但在逻辑上，划分通常是根据每个函数执行一个特定的任务来进行的。

 

函数声明告诉编译器函数的名称、返回类型和参数。函数定义提供了函数的实际主体。

 

C++ 标准库提供了大量的程序可以调用的内置函数。例如，函数 strcat() 用来连接两个字符串，函数 memcpy() 用来复制内存到另一个位置。

 

函数还有很多叫法，比如方法、子例程或程序，等等。

 

定义函数

C++ 中的函数定义的一般形式如下：

 

return_type function_name( parameter list )

{

  body of the function

}

在 C++ 中，函数由一个函数头和一个函数主体组成。下面列出一个函数的所有组成部分：

 

返回类型：一个函数可以返回一个值。return_type 是函数返回的值的数据类型。有些函数执行所需的操作而不返回值，在这种情况下，return_type 是关键字 void。

函数名称：这是函数的实际名称。函数名和参数列表一起构成了函数签名。

参数：参数就像是占位符。当函数被调用时，您向参数传递一个值，这个值被称为实际参数。参数列表包括函数参数的类型、顺序、数量。参数是可选的，也就是说，函数可能不包含参数。

函数主体：函数主体包含一组定义函数执行任务的语句。

实例

以下是 max() 函数的源代码。该函数有两个参数 num1 和 num2，会返回这两个数中较大的那个数：

 

函数声明

函数声明会告诉编译器函数名称及如何调用函数。函数的实际主体可以单独定义。

 

函数声明包括以下几个部分：

 

return_type function_name( parameter list );

针对上面定义的函数 max()，以下是函数声明：

 

int max(int num1, int num2);

在函数声明中，参数的名称并不重要，只有参数的类型是必需的，因此下面也是有效的声明：

 

int max(int, int);

当您在一个源文件中定义函数且在另一个文件中调用函数时，函数声明是必需的。在这种情况下，您应该在调用函数的文件顶部声明函数。

 

调用函数

创建 C++ 函数时，会定义函数做什么，然后通过调用函数来完成已定义的任务。

 

当程序调用函数时，程序控制权会转移给被调用的函数。被调用的函数执行已定义的任务，当函数的返回语句被执行时，或到达函数的结束括号时，会把程序控制权交还给主程序。

 

调用函数时，传递所需参数，如果函数返回一个值，则可以存储返回值。例如：

**函数参数**

如果函数要使用参数，则必须声明接受参数值的变量。这些变量称为函数的**形式参数**。

形式参数就像函数内的其他局部变量，在进入函数时被创建，退出函数时被销毁。

当调用函数时，有三种向函数传递参数的方式：

**参数的默认值**

当您定义一个函数，您可以为参数列表中后边的每一个参数指定默认值。当调用函数时，如果实际参数的值留空，则使用这个默认值。

这是通过在函数定义中使用赋值运算符来为参数赋值的。调用函数时，如果未传递参数的值，则会使用默认值，如果指定了值，则会忽略默认值，使用传递的值。请看下面的实例：

C++规定，设定函数形参默认值时，必须从函数最右边的形参开始，只有右边无形参或右边形参已经设定默认值时，左边形参才能设定默认值

函数调用时，缺省实参一样从右边开始，只有右边实参缺省时，左边实参才能缺省

如果函数由声明，已提供参数默认值，函数定义时不可重复提供参数默认值

函数调用实参缺省时，用于分隔实参的逗号也同样缺省

 

## 类型转换

**类型转换是将一个数据类型的值转换为另一种数据类型的值。**

**C++ 中有四种类型转换：静态转换、动态转换、常量转换和重新解释转换。**

### 静态转换（Static Cast）

**静态转换是将一种数据类型的值强制转换为另一种数据类型的值。**

**静态转换通常用于比较类型相似的对象之间的转换，例如将 int 类型转换为 float 类型。**

**静态转换不进行任何运行时类型检查，因此可能会导致运行时错误。**

**实例**

**int i = 10; float f = static_cast<float>(i); // 静态将int类型转换为float类型**

### 动态转换（Dynamic Cast）

**动态转换（dynamic_cast）是 C++ 中用于在继承层次结构中进行向下转换（downcasting）的一种机制。**

**动态转换通常用于将一个基类指针或引用转换为派生类指针或引用。**

**动态转换在运行时进行类型检查。如果转换失败，对于指针类型会返回 nullptr，对于引用类型则会抛出 std::bad_cast 异常。**

**语法：**

**dynamic_cast<目标类型>(表达式)**

- **目标类型：必须是指针或引用类型。**
- **表达式：需要转换的基类指针或引用。**

| **特性**           | **指针类型**                 | **引用类型**                 |
| ------------------ | ---------------------------- | ---------------------------- |
| **转换失败返回值** | **返回 nullptr**             | **抛出 std::bad_cast 异常**  |
| **适用场景**       | **向下转换、运行时类型检查** | **向下转换、运行时类型检查** |
| **性能开销**       | **较高**                     | **较高**                     |
| **基类要求**       | **必须具有虚函数**           | **必须具有虚函数**           |

 

 

 

 

 

 

 

 

 

1. dynamic_cast 的运行时类型检查（RTTI）

dynamic_cast 需要在运行时检查对象的实际类型，以确保转换的安全性。这种能力依赖于 RTTI（Run-Time Type Information），而 RTTI 的实现需要以下条件：

虚函数表（vtable）：
 当一个类有至少一个虚函数时，编译器会为该类生成一个虚函数表（vtable），其中不仅包含虚函数的地址，还会存储 类型信息（用于 RTTI）。

对象类型标识：
 对象的实际类型信息（如 Derived 或 Base）会存储在 vtable 中，供 dynamic_cast 在运行时查询。

虚析构函数的作用：

确保 delete ptr_base 能正确调用 Derived 的析构函数（多态销毁）。

为 Base 类生成 vtable，使 dynamic_cast 能通过 RTTI 检查 ptr_base 实际指向的对象是否为 Derived。

###   常量转换（Const Cast）

**常量转换用于将 const 类型的对象转换为非 const 类型的对象。**

**常量转换只能用于转换掉 const 属性，不能改变对象的类型。**

**实例**

**const int i = 10; int& r = const_cast<int&>(i); // 常量转换，将const int转换为int**

### 重新解释转换（Reinterpret Cast）

**重新解释转换将一个数据类型的值重新解释为另一个数据类型的值，通常用于在不同的数据类型之间进行转换。**

**重新解释转换不进行任何类型检查，因此可能会导致未定义的行为。**

**实例**

**int i = 10; float f = reinterpret_cast<float&>(i); // 重新解释将int类型转换为float类型**

### 不带初始化的定义

**带有静态存储持续时间的变量会被隐式初始化为 NULL（所有字节的值都是 0），其他所有变量的初始值是未定义的。**

**当局部变量被定义时，系统不会对其初始化，您必须自行对其初始化。定义全局变量时，系统会自动初始化为下列值：**

| **数据类型** | **初始化默认值** |
| ------------ | ---------------- |
| **int**      | **0**            |
| **char**     | **'\0'**         |
| **float**    | **0**            |
| **double**   | **0**            |
| **pointer**  | **NULL**         |

 

 

## 命名空间

 

-  命名空间可以嵌套
-  命名空间可以包含类和函数
-  **using namespace会引入命名空间中的所有符号**
-  **命名空间能解决名称冲突**

 

## C++ 中的变量声明

**变量声明向编译器保证变量以给定的类型和名称存在，这样编译器在不需要知道变量完整细节的情况下也能继续进一步的编译。变量声明只在编译时有它的意义，在程序连接时编译器需要实际的变量声明。**

**当您使用多个文件且只在其中一个文件中定义变量时（定义变量的文件在程序连接时是可用的），变量声明就显得非常有用。您可以使用 extern 关键字在任何地方声明一个变量。虽然您可以在 C++ 程序中多次声明一个变量，但变量只能在某个文件、函数或代码块中被定义一次。**

**同样的，在函数声明时，提供一个函数名，而函数的实际定义则可以在任何地方进行。**

### C++ 中的左值（Lvalues）和右值（Rvalues）

**C++ 中有两种类型的表达式：**

- **左值（lvalue）：指向内存位置的表达式被称为左值（lvalue）表达式。左值可以出现在赋值号的左边或右边。**
- **右值（rvalue）：术语右值（rvalue）指的是存储在内存中某些地址的数值。右值是不能对其进行赋值的表达式，也就是说，右值可以出现在赋值号的右边，但不能出现在赋值号的左边。**

**变量是左值，因此可以出现在赋值号的左边。数值型的字面值是右值，因此不能被赋值，不能出现在赋值号的左边。**

### C++ 变量作用域

**一般来说有三个地方可以定义变量：**

- **在函数或一个代码块内部声明的变量，称为局部变量。**
- **在函数参数的定义中声明的变量，称为形式参数。**
- **在所有函数外部声明的变量，称为全局变量。**

**作用域是程序的一个区域，变量的作用域可以分为以下几种：**

- **局部作用域：在函数内部声明的变量具有局部作用域，它们只能在函数内部访问。局部变量在函数每次被调用时被创建，在函数执行完后被销毁。**
- **全局作用域：在所有函数和代码块之外声明的变量具有全局作用域，它们可以被程序中的任何函数访问。全局变量在程序开始时被创建，在程序结束时被销毁。**
- **块作用域：在代码块内部声明的变量具有块作用域，它们只能在代码块内部访问。块作用域变量在代码块每次被执行时被创建，在代码块执行完后被销毁。**
- **类作用域：在类内部声明的变量具有类作用域，它们可以被类的所有成员函数访问。类作用域变量的生命周期与类的生命周期相同。**

**注意：如果在内部作用域中声明的变量与外部作用域中的变量同名，则内部作用域中的变量将覆盖外部作用域中的变量。**

**块作用域指的是在代码块内部声明的变量：**

**#include <iostream>

 int main() {
   int a = 10;
   {
     int a = 20; // 块作用域变量
     std::cout << "块变量: " << a << std::endl;
   }
   std::cout << "外部变量: " << a << std::endl;
   return 0;
 }**

**以上实例中，内部的代码块中声明了一个名为 a 的变量，它与外部作用域中的变量 a 同名。内部作用域中的变量 a 将覆盖外部作用域中的变量 a，在内部作用域中访问 a 时输出的是20，而在外部作用域中访问 a 时输出的是 10。**

**类作用域**

**类作用域指的是在类内部声明的变量**

**注意一定要是static。**

**Python中不同。**

**#include <iostream>

 class MyClass {
 public:
   static int class_var; // 类作用域变量
 };

 int MyClass::class_var = 30;

 int main() {
   std::cout << "类变量: " << MyClass::class_var << std::endl;
   return 0;
 }**

**局部变量**

**在函数或一个代码块内部声明的变量，称为局部变量。它们只能被函数内部或者代码块内部的语句使用。下面的实例使用了局部变量：**

 

**实例**

**#include <iostream>**

**using namespace std;**

 

**int main ()**

**{**

 **// 局部变量声明**

 **int a, b;**

 **int c;**

 

 **// 实际初始化**

 **a = 10;**

 **b = 20;**

 **c = a + b;**

 

 **cout << c;**

 

 **return 0;**

**}**

**全局变量**

**在所有函数外部定义的变量（通常是在程序的头部），称为全局变量。全局变量的值在程序的整个生命周期内都是有效的。**

 

**全局变量可以被任何函数访问。也就是说，全局变量一旦声明，在整个程序中都是可用的。下面的实例使用了全局变量和局部变量：**

 

**实例**

**#include <iostream>**

**using namespace std;**

 

**// 全局变量声明**

**int g;**

 

**int main ()**

**{**

 **// 局部变量声明**

 **int a, b;**

 

 **// 实际初始化**

 **a = 10;**

 **b = 20;**

 **g = a + b;**

 

 **cout << g;**

 

 **return 0;**

**}**

**在程序中，局部变量和全局变量的名称可以相同，但是在函数内，局部变量的值会覆盖全局变量的值。下面是一个实例：**

 

**实例**

**#include <iostream>**

**using namespace std;**

 

**// 全局变量声明**

**int g = 20;**

 

**int main ()**

**{**

 **// 局部变量声明**

 **int g = 10;**

 

 **cout << g;**

 

 **return 0;**

**}**

**当上面的代码被编译和执行时，它会产生下列结果：**

 

**10**

**当局部变量被定义时，系统不会对其初始化，您必须自行对其初始化。定义全局变量时，系统会自动初始化为下列值：**

 

**数据类型    初始化默认值**

**int 0**

**char '\0'**

**float   0**

**double 0**

**pointer NULL**

 

**块作用域指的是在代码块内部声明的变量：**

 

**实例**

**#include <iostream>**

 

**int main() {**

  **int a = 10;**

  **{**

​    **int a = 20; // 块作用域变量**

​    **std::cout << "块变量: " << a << std::endl;**

  **}**

  **std::cout << "外部变量: " << a << std::endl;**

  **return 0;**

**}**

**以上实例中，内部的代码块中声明了一个名为 a 的变量，它与外部作用域中的变量 a 同名。内部作用域中的变量 a 将覆盖外部作用域中的变量 a，在内部作用域中访问 a 时输出的是20，而在外部作用域中访问 a 时输出的是 10。**

 

**当上面的代码被编译和执行时，它会产生下列结果：**

 

**块变量: 20**

**外部变量: 10**

**类作用域**

**类作用域指的是在类内部声明的变量：**

 

**实例**

**#include <iostream>**

 

**class MyClass {**

**public:**

  **static int class_var; // 类作用域变量**

**};**

 

**int MyClass::class_var = 30;**

 

**int main() {**

  **std::cout << "类变量: " << MyClass::class_var << std::endl;**

  **return 0;**

**}**

**以上实例中，MyClass 类中声明了一个名为 class_var 的类作用域变量。可以使用类名和作用域解析运算符 :: 来访问这个变量。在 main() 函数中访问 class_var 时输出的是 30。**

 

**类变量: 30**

 

**但是在函数内的局部变量与全局变量是两个独立的变量，互不影响。**

 

**下述代码中，全局变量定义了一个int g=99，局部变量定义了一个int g=10，由于这两个g所在的作用域不同，所以各自独立。**

 

**#include <iostream>**

**using namespace std;**

 

**// 全局变量声明**

**int g = 99;**

 

**// 函数声明**

**int func();**

 

**int main()**

**{**

  **// 局部变量声明**

  **int g = 10;**

  **//cout << g;**

  **int kk = func();**

  **cout << kk;**

  **return 0;**

**}**

 

**// 函数定义**

**int func()**

**{**

  **return g;**

**}**

**当变量间出现重名的情况下，作用域小的屏蔽作用域大的**

**全局变量从定义处开始至程序结束起作用，即全局变量存在有效作用域**

**若要想让 main 函数也使用全局变量 a，可以用 extern 对全局变量进行声明，就可以合法使用了。**

**#include<iostream>**

**using namespace std;**

 

**int main()**

**{**

   **extern int a;**

   **cout<<"a= "<<a<<endl; //合法，输出10**

   **return 0;**

**}**

**int a=10; //全局变量从此处定义**

### 生命周期（生存期）和作用域

1. 核心区别

特性    作用域（Scope） 生存期（Lifetime）

定义    标识符（变量名、函数名等）在代码中的可见范围   对象占用的内存资源从创建到释放的时间周期

决定因素    代码的静态结构（如 {} 块、类定义、名字空间等）  对象的存储位置（栈、堆、静态区等）和创建方式

关注点  名称的可访问性  资源的有效性

示例    变量名只能在函数内部访问   对象的内存是否已被释放

2. 联系与互动

作用域是生存期的必要条件

 

一个对象的名称必须在其作用域内才能被访问，但对象可能在其名称失效后仍然存在（如动态分配的对象）。

 

反例：指针指向的动态对象（无名称作用域），但仍有生存期。

 

生存期可能超出作用域

 

静态局部变量：作用域是函数内，但生存期到程序结束。

 

cpp

void foo() {

  static int x = 0; // 作用域：foo()内；生存期：程序结束才销毁

}

动态分配对象：通过指针访问，无名称作用域，但生存期由 new/delete 控制。

 

cpp

int* p = new int(42); // 无名称作用域，但生存期持续到 delete

作用域结束时可能触发生存期结束

 

对于栈对象（局部变量、形参等），离开作用域时会自动销毁。

 

cpp

{

  int x = 10; // 作用域开始

}       // 作用域结束，x 的生存期终止

3. 典型场景对比

场景1：局部变量

cpp

void func() {

  int x = 10; // 作用域：func()内；生存期：func()执行期间

} // x 的作用域和生存期同时结束

作用域：仅在 func() 内可访问 x。

 

生存期：func() 执行时创建，返回时销毁。

 

场景2：静态局部变量

cpp

void counter() {

  static int count = 0; // 作用域：counter()内；生存期：程序结束

  count++;

}

作用域：count 仅在 counter() 内可见。

 

生存期：程序启动时初始化，结束时销毁（超出作用域仍存在）。

 

场景3：动态分配对象

cpp

int* createInt() {

  int* p = new int(42); // 作用域：p 在函数内；生存期：持续到 delete

  return p;

}

作用域：指针 p 的名称在 createInt() 外不可见。

 

生存期：*p 的内存生存期持续到手动 delete。

 

场景4：全局变量

cpp

int global = 100; // 作用域：文件内；生存期：程序启动到结束

作用域：从定义处到文件末尾可见。

 

生存期：程序运行时始终存在。

 

4. 关键结论

作用域是编译期概念，决定名称的可见性；生存期是运行时概念，决定资源的有效性。

 

作用域不直接控制生存期，但：

 

对于栈对象，作用域结束通常意味着生存期结束。

 

对于静态/全局对象，生存期可能远超作用域。

 

动态对象的生存期完全由程序员控制，与作用域无关。

 

5. 常见误区澄清

误区    正解

"作用域结束等于对象销毁" 仅适用于栈对象（局部变量、形参），不适用于静态/动态对象。

"名称不可见等于对象不存在"  对象可能仍存在（如通过指针访问动态对象）。

"生存期由作用域完全决定" 生存期由存储位置（栈、堆、静态区）决定，作用域仅影响名称访问。

程序运行中，变量或对象从开始建立到最后消失为止的周期称为变量或对象的生存期，

C++用标识符命名对象、函数和类型、类成员、类模板等，标识符作用域指通过该名字可以直接访问使用的范围。

C++名字作用域从小到大依次有：复合语句作用域、函数原型作用域、函数作用域、类作用域、名字空间作用域和文件作用域

对象的生存周期代表程序运行时，对象从建立到消失的时间周期。作用域和生存期是两个不同概念。

声明在函数原型里的形式参数名字，只在该函数声明内有效，作用域是该函数声明，函数声明内的形参名字也因此可以省略

声明或定义在复合语句内的名字，作用域只是改复合语句。作为对象名字时，相应对象称为局部对象；程序在开始执行该局部对象所在符合语句时，在运行栈上建立局部对象，程序执行完局部对象所在的复合语句离开时撤销局部对象。

声明或定义在函数体内的名字，作用域是该函数体，作为对象名字时，相应对象也是局部对象，程序执行完函数体离开时撤销局部对象。

函数定义时，形参作用域就是该函数定义，形参对象也是局部对象，程序在开始执行该局部对象所在函数时，在运行栈上建立局部对象，程序执行完函数离开时撤销局部对象

定义在类外和函数外，但是在名字空间里的标识符，具有该名字空间作用域，定义在名字空间里的对象在程序开始执行时，在全局对象和静态对象上专用存储区建立外部对象，程序执行结束时撤销外部对象。

定义在类外和函数外，不在名字空间内的对象时外部对象，作用域限定在定义开始到文件结束，在程序开始执行时在全局对象和静态对象专用存储区上建立，程序执行结束时撤销

带extern修饰的外部对象，代表本文件或其它文件定义的同名外部对象，作用域限定在该文件内

带static修饰的外部静态对象的生存期域普通外部对象的生存期相同，作用域限定在该文件内，其它文件不可引用该外部对象

带static 修饰的局部静态对象的作用域域普通局部对象的作用域相同，都限定在局部范围内，兵器为在程序第一次执行到该静态对象定义语句时没在全局对象和静态对象专用存储区上建立，在程序执行结束时撤销

定义不同作用域中的标识符名字相同时，根据最小作用域原则确定标识符代表的对象、函数、类型等，动态分配生成的uix是匿名对象，通过指针间接访问，new执行动态分配在堆空间生成，在delete删除操作时撤销

（删除只是指针所指向的内存空间，此时指针变为野指针）

 

1. 局部对象（复合语句/函数作用域）

cpp

void foo() {

  int x = 10; // 局部对象，作用域：foo函数内

  {

​    int y = 20; // 局部对象，作用域：当前复合语句内

​    cout << y;  // 输出 20

  }

  // cout << y;  // 错误！y 已失效

  cout << x;    // 输出 10

}

生存期：x 在 foo() 调用时创建，返回时销毁；y 在复合语句结束时销毁。

 

作用域：x 在整个函数内可见，y 仅在 {} 内可见。

 

2. 函数形参（函数原型/函数作用域）

cpp

void bar(int param); // 函数声明，param 作用域仅在此行

 

void bar(int param) { // param 作用域：整个函数体

  cout << param;  // 输出传入的值

}

生存期：param 在函数调用时创建，返回时销毁。

 

作用域：仅在函数体内有效。

 

3. 类作用域

cpp

class MyClass {

public:

  static int s_var; // 类静态成员，作用域：类内

  int m_var;     // 成员变量，作用域：类内

 

  void print() {

​    cout << m_var; // 访问成员变量

  }

};

int MyClass::s_var = 0; // 静态成员定义，作用域：全局

生存期：

 

m_var：随对象创建/销毁。

 

s_var：程序启动时初始化，结束时销毁。

 

作用域：

 

成员变量通过对象访问（如 obj.m_var）。

 

静态成员通过类名访问（如 MyClass::s_var）。

 

4. 名字空间作用域

cpp

namespace NS {

  int ns_var = 30; // 名字空间变量，作用域：NS 内

}

cout << NS::ns_var;  // 输出 30

生存期：程序启动时创建，结束时销毁。

 

作用域：通过 NS:: 访问。

 

5. 全局对象（文件作用域）

cpp

int global_var = 40; // 全局对象，作用域：当前文件

 

void func() {

  cout << global_var; // 输出 40

}

生存期：程序启动时创建，结束时销毁。

 

作用域：从定义处到文件末尾。

 

6. extern 和 static 修饰符

cpp

// file1.cpp

int shared_var = 50;   // 全局对象，可被其他文件访问

 

// file2.cpp

extern int shared_var;  // 声明共享变量

void use_shared() {

  cout << shared_var; // 输出 50

}

 

static int file_local = 60; // 文件静态对象，仅当前文件可见

extern：跨文件共享全局变量。

 

static：

 

修饰全局变量时，限制作用域为当前文件。

 

修饰局部变量时，延长生存期至程序结束（但作用域不变）。

 

7. 局部静态对象

cpp

void counter() {

  static int count = 0; // 局部静态对象

  count++;

  cout << count;    // 每次调用递增（1, 2, 3...）

}

生存期：首次调用时初始化，程序结束时销毁。

 

作用域：仍仅在函数内可见。

 

8. 动态分配对象（堆内存）

cpp

int* p = new int(70); // 动态分配，生存期由程序员控制

cout << *p;      // 输出 70

delete p;       // 手动释放

// cout << *p;     // 危险！p 现在是野指针

生存期：new 创建，delete 销毁。

 

作用域：通过指针访问，无名字作用域。

 

关键总结

类型    作用域规则  生存期规则

局部对象    复合语句/函数内 进入作用域时创建，离开时销毁

函数形参    函数体内    函数调用时创建，返回时销毁

类成员  类内（通过对象或类名访问）  随对象创建/销毁（静态成员全局生存）

名字空间变量   名字空间内  程序启动到结束

全局对象    定义处到文件末尾   程序启动到结束

static 局部变量  函数/复合语句内 首次调用时创建，程序结束时销毁

动态分配对象   通过指针访问（无名字作用域）   new 创建，delete 销毁

通过合理选择作用域和生存期，可以优化内存管理并避免悬空指针等问题！

在 C++ 中，函数原型（Function Prototype）中声明的形参名字的作用域是一个特殊规则。这句话的意思是：

 

函数原型中形参的作用域

仅在该函数声明内有效

函数原型中写的形参名字（如果有的话），只在原型这一行代码中可见，其他地方无法使用。

 

它只是声明参数类型和顺序，名字本身无实际意义（甚至可以省略）。

 

示例解析

 

cpp

// 函数原型（声明）

void foo(int x, double y); // x 和 y 的作用域仅限这一行

 

// 其他地方尝试使用 x 或 y 会报错

// cout << x; // 错误！x 未定义

 

// 函数定义（实现）

void foo(int a, double b) { // 形参名可以和原型不同（a代替x，b代替y）

  cout << a << ", " << b; // 这里只能用 a 和 b

}

原型中的 x 和 y 仅用于说明参数类型，实际定义时可以用其他名字（如 a 和 b）。

 

为什么可以省略名字？

因为函数原型只需要告诉编译器参数类型和顺序，名字是可选的：

 

cpp

void bar(int, char); // 合法！省略形参名

与函数定义中形参的区别

场景    形参名字作用域  是否必须写名字  示例

函数原型    仅限原型所在行  可省略  void func(int x);

函数定义    整个函数体  必须写  void func(int x) { ... }

核心概念

函数原型的作用：提前声明函数签名（返回类型、参数类型和顺序），便于编译器检查调用是否合法。

 

形参名字的局限性：原型中的名字无实际绑定，仅作为文档提示（类似注释）。

1. 定义在名字空间内的对象

语法形式

cpp

namespace MyNamespace {

  int x = 10; // 名字空间作用域的变量

  void foo() { /*...*/ }

}

核心特性

特性    说明

作用域  限定在名字空间 MyNamespace 内，需通过 MyNamespace::x 访问

存储期  静态存储期（程序启动时初始化，结束时销毁）

链接性  默认是外部链接（其他文件可通过 extern 声明访问）

访问控制    需显式指定名字空间（除非用 using 指令）

示例

cpp

// File1.cpp

namespace MyNamespace {

  int x = 10; // 名字空间作用域变量

}

 

// File2.cpp

extern int MyNamespace::x; // 声明其他文件中定义的变量

2. 定义在全局作用域（无名名字空间）的对象

语法形式

cpp

int y = 20; // 全局作用域变量（隐式属于无名名字空间）

核心特性

特性    说明

作用域  从定义处到文件末尾（文件作用域）

存储期  静态存储期（程序启动时初始化，结束时销毁）

链接性  默认是外部链接（其他文件可通过 extern 声明访问）

访问控制    直接通过变量名访问（或在其他文件中用 extern 声明）

示例

cpp

// File1.cpp

int y = 20; // 全局作用域变量

 

// File2.cpp

extern int y; // 声明其他文件中定义的全局变量

关键区别总结

特性    名字空间内的对象   全局作用域的对象

作用域  限定在名字空间内（需 Namespace:: 访问） 限定在当前文件（从定义处到文件末尾）

链接性  默认外部链接（可跨文件）   默认外部链接（可跨文件）

访问控制    需显式指定名字空间  直接访问或 extern 声明

典型用途    避免命名冲突，模块化代码   简单的全局变量（需谨慎使用）

 

**存储在静态数据区的变量会在程序刚开始运行时就完成初始化，也是唯一的一次初始化。共有两种变量存储在静态存储区：全局变量和 static 变量，只不过和全局变量比起来，static 可以控制变量的可见范围，说到底 static 还是用来隐藏的。虽然这种用法不常见。**

 

**PS：如果作为 static 局部变量在函数内定义，它的生存期为整个源程序，但是其作用域仍与自动变量相同，只能在定义该变量的函数内使用该变量。退出该函数后， 尽管该变量还继续存在，但不能使用它。**

 

**#include <iostream>**

**using namespace std;**

 

**int count = 1; //全局变量**

 

**int fun()**

**{**

  **static int count = 10; // 在第一次进入这个函数的时候，变量 count 被初始化为 10！并接着自减 1，以后每次进入该函数，count 的值是上一次函数运行之后的值**

  **return count--;    // 就不会被再次初始化了，仅进行自减 1 的操作；在 static 发明前，要达到同样的功能，则只能使用全局变量**

**}**

 

**//int count = 1; //全局变量**

 

**int main()**

**{**

   **cout<<"global "<<"local staic"<<endl;**

   **for(; count <= 10; ++count)**

​    **cout<<count<<"    "<<fun()<<endl;**

   **return 0;**

**}**

**并且，由此可见全局变量和局部静态变量 count 的作用域是不同的**

**全局变量和和局部变量同名时，可通过域名在函数中引用到全局变量，不加域名解析则引用局部变量**

 

**#include<iostream>**

**using namespace std;**

 

**int a = 10;**

**int main()**

**{**

  **int a = 20;**

  **cout << ::a << endl;  // 10**

  **cout << a << endl;   // 20**

  **return 0;**

**}**

**C++ 全局变量、局部变量、静态全局变量、静态局部变量的区别**

 

**C++ 变量根据定义的位置的不同的生命周期，具有不同的作用域，作用域可分为 6 种：全局作用域，局部作用域，语句作用域，类作用域，命名空间作用域和文件作用域。**

 

**从作用域看：**

 

**全局变量具有全局作用域。全局变量只需在一个源文件中定义，就可以作用于所有的源文件。当然，其他不包含全局变量定义的源文件需要用extern 关键字再次声明这个全局变量。**

 

**静态局部变量具有局部作用域，它只被初始化一次，自从第一次被初始化直到程序运行结束都一直存在，它和全局变量的区别在于全局变量对所有的函数都是可见的，而静态局部变量只对定义自己的函数体始终可见。**

 

**局部变量也只有局部作用域，它是自动对象（auto），它在程序运行期间不是一直存在，而是只在函数执行期间存在，函数的一次调用执行结束后，变量被撤销，其所占用的内存也被收回。**

 

**静态全局变量也具有全局作用域，它与全局变量的区别在于如果程序包含多个文件的话，它作用于定义它的文件里，不能作用到其它文件里，即被static关键字修饰过的变量具有文件作用域。这样即使两个不同的源文件都定义了相同名字的静态全局变量，它们也是不同的变量。**

 

**从分配内存空间看：**

 

**全局变量，静态局部变量，静态全局变量都在静态存储区分配空间，而局部变量在栈里分配空间。**

 

**全局变量本身就是静态存储方式， 静态全局变量当然也是静态存储方式。这两者在存储方式上并无不同。这两者的区别虽在于非静态全局变量的作用域是整个源程序，当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。 而静态全局变量则限制了其作用域， 即只在定义该变量的源文件内有效，在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用，因此可以避免在其它源文件中引起错误。**

 

 **1)、静态变量会被放在程序的静态数据存储区（数据段）(全局可见)中，这样可以在下一次调用的时候还可以保持原来的赋值。这一点是它与堆栈变量和堆变量的区别。**

 **2)、变量用static告知编译器，自己仅仅在变量的作用范围内可见。这一点是它与全局变量的区别。**

**从以上分析可以看出， 把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态变量后是改变了它的作用域，限制了它的使用范围。因此static 这个说明符在不同的地方所起的作用是不同的。应予以注意。**

 

**Tips:**

 

**A、若全局变量仅在单个C文件中访问，则可以将这个变量修改为静态全局变量，以降低模块间的耦合度；**

**B、若全局变量仅由单个函数访问，则可以将这个变量改为该函数的静态局部变量，以降低模块间的耦合度；**

**C、设计和使用访问动态全局变量、静态全局变量、静态局部变量的函数时，需要考虑重入问题，因为他们都放在静态数据存储区，全局可见；**

**D、如果我们需要一个可重入的函数，那么，我们一定要避免函数中使用static变量(这样的函数被称为：带“内部存储器”功能的的函数)**

**E、函数中必须要使用static变量情况:比如当某函数的返回值为指针类型时，则必须是static的局部变量的地址作为返回值，若为auto类型，则返回为错指针。**

**-----------------------------------------------------------------------------------------------------------**

 

**static 全局变量:改变作用范围，不改变存储位置**

 

**static 局部变量：改变存储位置，不改变作用范围**

 

**静态函数 ：在函数的返回类型前加上static关键字,函数即被定义为静态函数。静态函数与普通函数不同，它只能在声明它的文件当中可见，不能被其它文件使用。**

 

**如果在一个源文件中定义的函数，只能被本文件中的函数调用，而不能被同一程序其它文件中的函数调用，这种函数也称为内部函数。定义一个内部函数，只需在函数类型前再加一个“static”关键字即可。**

**全局变量和局部变量作用域不同，static 关键字可限定引用范围：**

**#include <stdio.h>**

 

**int s32Test;  // 定义全局变量，系统默认初始化0**

 

**static void Fun(); // 声明只限定在被当前文件调用的函数**

 

 

**static void Fun()**

**{**

  **int s32Test = 1; // 局部变量,如果不初始化，会是一个随机数值**

 

  **//与全局变量名相同，会屏蔽全局变量调用,s32Test = 1**

  **printf("This is Fun()，s32Test = %d!", s32Test);** 

**}**

 

**int main()**

**{**

  **Fun();**

  **return 0;**

**}**

 

**MyClass::class_var 中的 :: 是作用域解析运算符，用于访问类的静态成员。而 std::cout 中的 :: 用于指定 cout 是 std 命名空间中的对象。这两者虽然在使用语法上看起来相似，但它们代表的含义和用途完全不同。**

**#include <iostream>**

**using namespace std;**

 

**int\* leakyFunc() {**

  **int x = 10;     // 作用域：函数内；生存期：函数结束**

  **int\* p = new int(20); // 作用域：p在函数内；生存期：持续到delete**

  **return p;      // 返回指针，x 已销毁，\*p 仍有效**

**}**

 

**int main() {**

  **int\* ptr = leakyFunc();**

  **cout << \*ptr;    // 输出 20（生存期未结束，但 ptr 无名称作用域）**

  **delete ptr;     // 必须手动释放**

  **return 0;**

**}**

### 变量定义的一般形式如下：

**类型 变量；**

**类型 变量=初始表达式**

**类型 变量 （初始化表达式）**

**类型 变量 {初始化表达式} //C++11**

**类型 变量列表**

**定义多个具有相同类型的变量，变量列表里不同变量用逗号分隔**

 

**Extern int globalint，外部变量声明语句，不可初始化extern存储类别声明的语句，无定义性作用。**

**为避免二义性，定义变量如果没有初始化，不可带小括号**

**栈和函数调用的实现**

**每次遇到函数调用，就在运行栈上发呢配空间**

**1.**   **函数执行完毕后返回的地址**

**2.**   **形参和函数返回值类型**

**3.**   **函数体内的局部对象**

**4.**    

 

### 引用

 

引用变量是一个别名，也就是说，它是某个已存在变量的另一个名字。

一旦把引用初始化为某个变量，就可以使用该引用名称或变量名称来指向变量。

引用必须在定义时初始化，并且一旦绑定到一个变量后，就不能再绑定到其他变量。

引用的语法如下：

int a = 10;

int &ref = a; // ref 是 a 的引用

- int &ref 表示 ref 是一个 int 类型的引用。
- ref 是 a 的别名，对 ref 的操作会直接作用于 a。

**C++ 引用 vs 指针**

引用很容易与指针混淆，它们之间有三个主要的不同：

- 不存在空引用，引用必须连接到一块合法的内存。
- 一旦引用被初始化为一个对象，就不能被指向到另一个对象。指针可以在任何时候指向到另一个对象。
- 引用必须在创建时被初始化。指针可以在任何时间被初始化。
- 引用的对象必须是一个变量，而指针必须是一个地址。

| **特性**                | **引用**                                                     | **指针**                                                     |
| ----------------------- | ------------------------------------------------------------ | ------------------------------------------------------------ |
| **定义与初始化**        | 必须初始化，且不能为 null。                                  | 可以不初始化，可以在后续代码中指向其他对象，可以为 null。    |
| **语法**                | 使用 & 声明，例如：int &ref = a;                             | 使用 * 声明，例如：int *ptr = &a;                            |
| **重新绑定**            | 不能重新绑定，一旦初始化后始终引用同一个对象。               | 可以重新指向其他对象，例如：ptr = &b;                        |
| **空值（Nullability）** | 不能为 null，必须绑定到有效的对象。                          | 可以为 null，表示不指向任何对象。                            |
| **内存占用**            | 不占用额外内存（编译器通常将其优化为直接操作所引用的对象）。 | 占用额外内存（存储地址，通常是一个机器字长，如4字节或8字节）。 |
| **访问方式**            | 直接使用，无需解引用操作符，例如：ref = 10;                  | 需要使用 * 解引用操作符访问或修改所指向的对象，例如：*ptr =  10; |
| **多级间接访问**        | 不支持多级间接访问（不能有引用的引用）。                     | 支持多级间接访问（如指针的指针：int **pptr;）。              |
| **函数参数传递**        | 常用于函数参数传递，语法简洁，例如：void func(int &x) { x = 10; } | 也可以用于函数参数传递，但需要使用解引用操作符，例如：void func(int *x) { *x = 10; } |
| **数组与引用**          | 不能直接创建引用数组，但可以创建数组的引用，例如：int (&ref)[10] = arr; | 可以创建指针数组，也可以创建指向数组的指针，例如：int *ptrArr[10]; |
| **安全性**              | 更安全，不能为 null，且语法更直观。                          | 更灵活，但容易出错（如空指针、野指针等）。                   |
| **底层实现**            | 通常通过指针实现，但编译器会优化为直接操作所引用的对象。     | 直接存储目标对象的内存地址。                                 |

#### 隐藏的操作

**(1) 隐藏解引用（\* 操作符）**

- **指针版本**：

int x = 10;

int *p = &x; *//* *显式取地址*

*p = 20;   *//* *显式解引用*

- **引用版本**：

int x = 10;

int &r = x;  *//* 编译器自动处理地址（类似 `int *const r = &x`）

r = 20;    *//* *编译器自动解引用（实际生成 `\*r = 20`）*

**隐藏的操作**：**int &r = x** 实际上被编译为 **int \*const r = &x**（但 **r** 的地址不可见）。

**引用不能重新绑定**：

int x = 10, y = 20;

int &r = x;

r = y;  *//* *不是重新绑定，而是把 y 的值赋给 x！*

**隐藏的操作**：引用在初始化后，其绑定的地址固定（类似 **int \*const p**）

**(4) 禁止 NULL 引用（隐藏空指针检查）**

- **指针可以为 nullptr**：

int *p = nullptr; *//* *合法*

- **引用必须绑定有效对象**：

int &r = nullptr; *//* *编译错误！*

**隐藏的操作**：编译器确保引用总是绑定有效内存（但可以通过非法手段绕过，如 **int &r = \*(int\*)0**，但这是未定义行为）。

**4. 引用隐藏的操作总结**

| **隐藏的操作**   | **引用示例**                  | **实际编译器行为**     |
| ---------------- | ----------------------------- | ---------------------- |
| **解引用 \***    | **r = 20**                    | ***(&r) = 20**         |
| **取地址 &**     | **int &r = x**                | **int \*const r = &x** |
| **禁止重新绑定** | **r = y**（赋值，非重绑定）   | 类似 ***const** 指针   |
| **禁止 nullptr** | **int &r = nullptr;**（错误） | 编译期检查             |

 

### 指针

#### 指针的补充

#####  关键对比

| **特性**        | **int \*ptr[N]（指针数组）** | **int (\*ptr)[N]（数组指针）** |
| --------------- | ---------------------------- | ------------------------------ |
| **类型**        | 数组，元素为 **int\***       | 指针，指向 **int[N]**          |
| **ptr 的本质**  | 数组名（地址常量）           | 指针变量                       |
| **sizeof(ptr)** | **N \* sizeof(int\*)**       | **sizeof(int\*)**（指针大小）  |
| **元素访问**    | **ptr[i]**（返回 **int\***） | **(\*ptr)[i]**（返回 **int**） |
| **典型场景**    | 存储多个指针                 | 指向一个完整数组               |

**多维数组传参**：

- 函数接收二维数组时，参数应声明为 **int (\*ptr)[N]**，而不是 **int     \**ptr**。

##### 常见误区

**❌ 误区 1：int \*p = new int; 是空指针**

- **正确**：**p** 指向堆内存，不是 **nullptr**（除非 **new** 失败且用了 **nothrow**）。
- **错误**：认为 **p** 是空指针，导致后续解引用时未初始化错误。

**❌ 误区 2：int \*p; 是空指针**

- **正确**：未初始化的指针是**野指针**（指向随机地址），不是 **nullptr**。
- **错误**：假设未初始化的指针默认是 **nullptr**（C++ 不会自动初始化局部变量）。

int *p = nullptr; *// p* *是空指针*

直接 **int \*p;**（不初始化）是**未定义行为**，可能是野指针（指向随机地址）

 

| **概念**   | **定义**                     | **示例**                | **后果**                 |
| ---------- | ---------------------------- | ----------------------- | ------------------------ |
| **空指针** | 显式指向 **nullptr** 的指针  | **int  \*p = nullptr;** | 解引用时崩溃（明确错误） |
| **野指针** | 指向无效内存的指针（未置空） | **delete  p;** 后未置空 | 解引用导致 **UB**        |

1. 空指针（Null Pointer）

定义

空指针是指 明确赋值为 nullptr（C++11 起）或 NULL（传统 C）的指针，表示它不指向任何有效内存地址。

 

示例：

 

cpp

int *p = nullptr; // 空指针

if (p == nullptr) {

  cout << "p 是空指针";

}

特点

安全：解引用空指针会导致 编译错误或运行时崩溃（如 Segmentation Fault），但这是可预测的行为。

 

用途：用于初始化指针或表示“无目标”。

 

2. 野指针（Dangling Pointer）

定义

野指针是指 指向已释放或无效内存的指针，但指针本身未被置空。

 

常见场景：

 

释放后未置空：

 

cpp

int *p = new int(5);

delete p; // p 变为野指针（仍保留原地址）

// cout << *p; // 未定义行为！

指向局部变量（栈内存失效）：

 

cpp

int *getPointer() {

  int x = 10;

  return &x; // 返回局部变量的地址（函数结束后 x 失效）

}

int *p = getPointer(); // p 是野指针

##### 指针到底是什么？

**"指针其实就是地址"这句话基本是正确的，但需要一些补充和澄清**：

1. **本质关系**：
   - 指针的本质是存储内存地址的变量，它的值确实代表一个内存地址。
   - 例如在C语言中：**int \*p = &a;**，这里**p**存储的就是变量**a**的内存地址。

##### 数组名就是这片内存单元的起始地址即指针

即存储数组首元素的指针，其本身也存放在数组首元素的地址 即a的内容和&a的内容是一样的!

- **数组名 a 会被隐式转换为首元素的指针**（即 建立一个int *a=**&a[0]**），类型是 **T\***（例如 **int\***）。

**即存储在数组首元素的指针，其本身也存放在数组首元素的地址**

- **&a 的类型是“指向整个数组的指针”（即 int (\*)[5]），而非指向单个元素的指针。**

**虽然 &a 和 a 的数值相同（都指向内存的同一位置，如 0x0004），但它们的类型不同，导致指针运算行为不同：**

**即\*a=&a;**

**即a的地址和a存储的值是一样的。**

printf("%p\n", &a);  *//* *输出 0x0004（与 a 相同）*

printf("%p\n", &a + 1); *//* *输出 0x0018（假设 int 占 4 字节，跳过整个数组 5\*4=20 字节）*

printf("%p\n", a + 1); *//* *输出 0x0008（跳过 1 个 int，4 字节）*

 

  int a[5] = {1, 2, 3, 4, 5};

  printf("%p\n", a); // 输出数组首元素地址（如 0x0004）

  printf("%p\n", &a[0]); // 输出数组首元素地址（如 0x0004）

  printf("%p\n", &a); // 输出整个数组的地址（如 0x0004），与首元素地址相同

**3. 为什么可以对 a 取地址？**

- **数组名 a 是一个标识符**，代表整个数组对象，而非单纯的指针变量。
- C/C++ 允许对任何对象（包括数组）使用 **&** 运算符获取其地址。
- **关键区别**：
  - **a**：隐式转换为 **int\***（指向首元素）。
  - **&a**：显式获取数组对象的地址，类型是 **int      (\*)[5]**。

**4. 类型系统的视角**

| **表达式** | **类型**        | **含义**                     |
| ---------- | --------------- | ---------------------------- |
| **a**      | **int\***       | 首元素地址（隐式转换）       |
| **&a**     | **int (\*)[5]** | 整个数组的地址（指针到数组） |
| **a[0]**   | **int**         | 数组第一个元素               |

**核心结论**：
 **可以对数组名 a 取地址（&a），因为 a 是一个完整的数组对象，而非单纯的指针。&a 的类型是指向数组的指针，与 a 的首元素指针类型不同，但地址值相同。**

**int a[5][2] = {{1, 2}, {3, 4}, {5, 6}, {7, 8}, {9, 10}};**

 

| **表达式** | **类型**             | **隐式转换行为（退化）**             | **实际含义**                     |
| ---------- | -------------------- | ------------------------------------ | -------------------------------- |
| **a**      | **int[5][2]**        | 退化为 **int (\*)[2]**               | 指向第一个子数组 **a[0]** 的指针 |
| **&a**     | **int (\*)[5][2]**   | 无                                   | 指向整个二维数组的指针           |
| **a[0]**   | **int[2]**           | 退化为 **int\***                     | 指向 **a[0][0]** 的指针          |
| ***a**     | **int[2]**（解引用） | 退化为 **int\***（与 **a[0]** 相同） | 指向 **a[0][0]** 的指针          |

  printf("a:   %p (类型: int (*)[2])\n", a);

  printf("&a[0]: %p (类型: int (*)[2])\n", &a[0]);

  printf("&a:   %p (类型: int (*)[5][2])\n", &a);

  printf("*a:   %p (类型: int*, 指向 a[0][0])\n", *a);

  printf("a[0]:  %p (同 *a)\n", a[0]);

  printf("&a[0][0]: %p (同 *a)\n", &a[0][0]);

虽然 **a**、**&a**、***a** 的地址值相同，但类型不同导致指针运算结果不同：

printf("a + 1:  %p (跳过 1 个子数组, +8 字节)\n", a + 1);

printf("&a + 1: %p (跳过整个数组, +40 字节)\n", &a + 1);

printf("*a + 1: %p (跳过 1 个 int, +4 字节)\n", *a + 1);

- **printf("%p\n",     \*a); 在二维数组中合法**：
  - ***a** 退化为 **int\***，与 **%p** 兼容，输出 **a[0][0]** 的地址。
- **与一维数组的区别**：
  - 一维数组的 ***a** 是值（**int**），二维数组的 ***a** 是指针（**int\***）。
- **核心原因**：
  - 二维数组的层级解引用触发了两次隐式转换（**a → int      (\*)[2]** → ***a → int\***），而一维数组只有一次（**a → int\*** → ***a → int**）。

**关键结论**：
 **在二维数组中，\*a 退化为指向首元素的指针（int\*），因此可以用 %p 输出地址；而在一维数组中，\*a 是整数值，与 %p 不兼容。**

然而小心未定义行为

- **一维数组 int b[5]**：
  - ***b** 是 **b[0]**（**int** 类型），与 **%p** 不匹配，导致未定义行为。
- **二维数组 int a[5][2]**：
  - ***\*a** 是 **a[0][0]**，int 类型，导致未定义行为

 

#### Int *p 与 int* p

##### int *p

更符合C的习惯

*p是一个int类型的变量

结合硬件层面来说，指针只是保存内存的一个地址，不管你保存的是int char还是long，指针就是个固定长度的[内存地址](https://zhida.zhihu.com/search?content_id=47510914&content_type=Answer&match_order=1&q=内存地址&zhida_source=entity)，**它本身没有类型**，只是可以把它指向的内存中保存的数据解析为各种类型。

所以，指针没有类型，所以不存在xx类型的[指针](https://zhida.zhihu.com/search?content_id=47510914&content_type=Answer&match_order=4&q=指针&zhida_source=entity)这一说，只存在这个指针保存的数据是什么类型。因此，星号（*）应该和变量结合，而不应该和类型结合。

[*]是运算符，所以它的正确使用是作用在操作数上[而不是和int类型组合]，这在第二幅图片也有说明即[[表达式](https://zhida.zhihu.com/search?content_id=47510914&content_type=Answer&match_order=1&q=表达式&zhida_source=entity)*ip]。

因此，int表示的是[*ip]这个表达式的类型。从表达式[*ip]反向推出未使用*操作的ip是个地址。

##### int* p   

C++的习惯

Int*是一种类型——>指向int 的指针。P的类型是int*

我们采取第一种方式，即int *p。

 

## C++ 常量

**常量是固定值，在程序执行期间不会改变。这些固定的值，又叫做字面量。**

**常量可以是任何的基本数据类型，可分为整型数字、浮点数字、字符、字符串和布尔值。**

**常量就像是常规的变量，只不过常量的值在定义后不能进行修改。**

**#define 预处理器**

**下面是使用 #define 预处理器定义常量的形式：**

**const 关键字**

**您可以使用 const 前缀声明指定类型的常量，如下所示：**

**const type variable = value;**

**常量必须在定义时初始化**

**Const int \* p=&I,常量指针，不可通过指针改变值，但是指针可以改变指向的地址**

**Int \* const p =&I,指针常量，不可改变指向的地址，但是可以改变值**

 

 

## 动态内存

 

- **栈：**在函数内部声明的所有变量都将占用栈内存。
- **堆：**这是程序中未使用的内存，在程序运行时可用于动态分配内存。

很多时候，您无法提前预知需要多少内存来存储某个定义变量中的特定信息，所需内存的大小需要在运行时才能确定。

在 C++ 中，您可以使用特殊的运算符为给定类型的变量在运行时分配堆内的内存，这会返回所分配的空间地址。这种运算符即 **new** 运算符。

如果您不再需要动态分配的内存空间，可以使用 **delete** 运算符，删除之前由 new 运算符分配的内存。

**new 和 delete 运算符**

下面是使用 new 运算符来为任意的数据类型动态分配内存的通用语法：

new data-type;

在这里，**data-type** 可以是包括数组在内的任意内置的数据类型，也可以是包括类或结构在内的用户自定义的任何数据类型。让我们先来看下内置的数据类型。例如，我们可以定义一个指向 double 类型的指针，然后请求内存，该内存在执行时被分配。我们可以按照下面的语句使用 **new** 运算符来完成这点：

double* pvalue = NULL; // 初始化为 null 的指针

 pvalue = new double; // 为变量请求内存

如果自由存储区已被用完，可能无法成功分配内存。所以建议检查 new 运算符是否返回 NULL 指针，并采取以下适当的操作：

double* pvalue = NULL; 

if( !(pvalue = new double ))

 { cout << "Error: out of memory." <<endl; 

exit(1); }

- **赋值表达式的结果**：
       C/C++ 中，赋值表达式（如 **a = b**）的返回值是赋值后的左值（即 **a** 的值）。因此 **pvalue     = new double** 的返回值是 **pvalue** 的值（即新分配的地址或 **nullptr**）。

**malloc()** 函数在 C 语言中就出现了，在 C++ 中仍然存在，但建议尽量不要使用 malloc() 函数。new 与 malloc() 函数相比，其主要的优点是，new 不只是分配了内存，它还创建了对象。

在任何时候，当您觉得某个已经动态分配内存的变量不再需要使用时，您可以使用 delete 操作符释放它所占用的内存，如下所示：

delete pvalue;    // 释放 pvalue 所指向的内存

**数组的动态内存分配**

假设我们要为一个字符数组（一个有 20 个字符的字符串）分配内存，我们可以使用上面实例中的语法来为数组动态地分配内存，如下所示：

char* pvalue = NULL;  // 初始化为 null 的指针

pvalue = new char[20]; // 为变量请求内存

要删除我们刚才创建的数组，语句如下：

delete [] pvalue;    // 删除 pvalue 所指向的数组

下面是 new 操作符的通用语法，可以为多维数组分配内存，如下所示：

**一维数组**

// 动态分配,数组长度为 m int *array=new int [m]; //释放内存 delete [] array;

**二维数组**

int **array; // 假定数组第一维长度为 m， 第二维长度为 n // 动态分配空间 array = new int *[m]; for( int i=0; i<m; i++ ) { array[i] = new int [n]; } //释放 for( int i=0; i<m; i++ ) { delete [] array[i]; }

int ***array;

// 假定数组第一维为 m， 第二维为 n， 第三维为h

// 动态分配空间

array = new int **[m];

for( int i=0; i<m; i++ )

{

  array[i] = new int *[n];

  for( int j=0; j<n; j++ )

  {

​    array[i][j] = new int [h];

  }

}

//释放

for( int i=0; i<m; i++ )

{

  for( int j=0; j<n; j++ )

  {

​    delete[] array[i][j];

  }

  delete[] array[i];

}

delete[] array;

 

delete[] p和delete p对于简单类型的释放没什么太大区别，前者确实会释放整个数组内存，后者只释放数组开头元素的内存在delete操作后p实际上成为了野指针，不再指向任何有效值。这也是为什么打印出了两个奇怪值的原因。

new 的功能是在堆区新建一个对象，并返回该对象的指针。

所谓的**【新建对象】**的意思就是，将调用该类的构造函数，因为如果不构造的话，就不能称之为一个对象。

而 malloc 只是机械的分配一块内存，如果用 mallco 在堆区创建一个对象的话，是不会调用构造函数的。

严格说来用 malloc 不能算是新建了一个对象，只能说是分配了一块与该类对象匹配的内存而已，然后强行把它解释为【这是一个对象】，按这个逻辑来，也不存在构造函数什么事。

同样的，用 delete 去释放一个堆区的对象，会调用该对象的析构函数。

用 free 去释放一个堆区的对象，不会调用该对象的析构函数。

 

## 基础数据结构

### 1.结构体

**结构体与类的区别**

**在 C++ 中，struct 和 class 本质上非常相似，唯一的区别在于默认的访问权限：**

- **struct 默认的成员和继承是 public。**
- **class 默认的成员和继承是 private。**

**你可以将 struct 当作一种简化形式的 class，适合用于没有太多复杂功能的简单数据封装。**

### 2.数组（Array）

**数组是最基础的数据结构，用于存储一组相同类型的数据。**

### 3. 类（Class）

**类是 C++ 中用于面向对象编程的核心结构，允许定义成员变量和成员函数。与 struct 类似，但功能更强大，支持继承、封装、多态等特性。**

### 4. 链表（Linked List）

 

**struct Node {
   int data;
   Node\* next;
 };
 Node\* head = nullptr;
 Node\* newNode = new Node{10, nullptr};
 head = newNode; // 插入新节点**

## POD的概念

POD 是 C++ 中一个比较重要的概念，POD 是英文 Plain Old Data 的缩写（通俗讲就是类或结构体通过二进制拷贝后还能保持其数据不变），用来描述一个类型（包括 class、union 和 struct等）的属性。其中Plain表示这个类型是个平凡的类，Old表示其与C的兼容性。C++11 中将划分为两个基本概念：平凡的（trivial）和标准布局（standard layout）。

POD的好处：

- 字节赋值，可以放心使用memset和memcpy对POD类型进行初始化和拷贝。
- 提供对C内存兼容。POD类型数据在C与C++间的操作总是安全的。
- 保证静态初始化的安全有效。POD类型对象初始化往往更简单。

 

### POD 的特征

是不是 POD 类型的，可以用 [is_pod](https://zhida.zhihu.com/search?content_id=9183303&content_type=Article&match_order=1&q=is_pod&zhida_source=entity)<T>::value 来判断。那什么样的类、结构体是拥有 POD 特性的呢？要求有两个：一个是它必须很平凡、很普通；另一个是布局有序。

#### 1、平凡的（trivial）

**一个trivial class 或struct 应符合以下定义：**

- **拥有平凡的默认构造函数（trivial constructor）和析构函数（trivial     destructor）。如果用户定义了构造函数或析构函数，则不能称为POD类型。**
- **拥有平凡的赋值构造函数（trivial copy constructor）和移动构造函数（trivial     move constructor）。**
- **拥有平凡的复制赋值运算符（trivial assignment operator）和移动赋值运算符（trivial     move operator）。**
- **不能包含虚函数和虚基类。**

**在c++11中可以使用default关键字来显示声明缺省版本的构造函数从而是类型恢复平凡化（第二、第三规则类似），同时c++11也提供了一个类模板来帮助我们识别一个类是否平凡的。**

**template <typename T>struct std::is_trival**

#### 2、标准布局（standard layout）

满足如下条件的类或结构体是标准布局的：

-  所有非静态成员具有相同的访问权限，比如都是private权限，或者都是public，或者都为protected。
- 在类或结构体的继承时，满足以下两种情况之一：
  - 派生类中有非静态成员，且只有一个仅包含静态成员的基类。
  - 基类有非静态成员，而派生类没有非静态成员。
  - class      B1 { static int n; }; 
  - class      B2 : B1 { int n1; }; //派生类 B2 中有非静态成员，且只有一个仅包含静态成员的基类 B1，所以B2为标准布局。

class B3 : B2 { static int n2; }; //基类 B2 有非静态成员，而派生类 B3 没有非静态成员，所以B3为标准布局。

 

- 类中第一个非静态成员的类型与基类不同。（基于c++中优化不包括成员的基类而产生的，在c++标准中，如果基类没有成员，基类不应占空间，所以标准允许派生类的第一个成员与基类共享地址，此时基类并没有占据任何实际空间。但此时若派生类第一个成员类型仍然是基类，编译器会为基类分配一个字节空间，因为c++标准要求类型相同的对象地址不同，因此c++11强制要求POD类型的派生类第一个非静态成员类型必须不同于基类）
- 没有虚函数和虚拟基类。
- 所有非静态成员均符合标准布局类型，其基类也符合标准布局。

 

#### 3、POD的使用

当一个数据类型满足“trivial”和“standard layout”，我们则认为它是POD数据库。

c++ 提供了模板来判断一个类或结构体对象是否标准布局

template <typename T> structstd::is_standard_layout; //头文件为<type_traits>

template <typename T> struct std::is_pod //判断一个类型是否是POD，头文件为<type_traits>

所有兼容C语言的数据类型都是 POD 类型（struct、union 等不能违背上述规则）。

 

## 类和对象

类用于指定对象的形式，是一种用户自定义的数据类型，它是一种封装了数据和函数的组合。

类中的数据称为成员变量（数据成员），函数称为成员函数（函数成员）。类可以被看作是一种模板，可以用来创建具有相同属性和行为的多个对象。

定义一个类需要使用关键字 **class**，然后指定类的名称，并类的主体是包含在一对花括号中，主体包含类的成员变量和成员函数。

定义一个类，本质上是定义一个数据类型的蓝图，它定义了类的对象包括了什么，以及可以在这个对象上执行哪些操作。

 

 

![img](data:image/png;base64,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)

成员包含数据成员和函数成员

以下实例我们使用关键字 **class** 定义 Box 数据类型，包含了三个成员变量 length、breadth 和 height：

class Box

 { public: double length; // 盒子的长度 

double breadth; // 盒子的宽度

 double height; // 盒子的高度 };

关键字 **public** 确定了类成员的访问属性。在类对象作用域内，公共成员在类的外部是可访问的。您也可以指定类的成员为 **private** 或 **protected**。

对象是根据类来创建的。声明类的对象，就像声明基本类型的变量一样。

**访问数据成员**

类的对象的公共数据成员可以使用直接成员访问运算符 **.** 来访问。

需要注意的是，私有的成员和受保护的成员不能使用直接成员访问运算符 (.) 来直接访问。

![img](data:image/png;base64,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)

类名 对象名；

类名 对象名=初始化表达式

类名 对象名 （初始表达式）

类名 对象名 {初始化表达式}

类名 对象名列表

 

对象。数据成员们

对象. 函数成员（是餐标）

### 类的成员函数

是指那些把定义和原型写在类定义内部的函数，就像类定义中的其他变量一样。类成员函数是类的一个成员，它可以操作类的任意对象，可以访问对象中的所有成员。

成员函数可以定义在类定义内部，或者单独使用**范围解析运算符 ::** 来定义。在类定义中定义的成员函数把函数声明为**内联**的，即便没有使用 inline 标识符。

也可以在类的外部使用**范围解析运算符 ::** 定义该函数。

需要强调一点，在 :: 运算符之前必须使用类名。调用成员函数是在对象上使用点运算符（**.**），这样它就能操作与该对象相关的数据。

**::** 叫作用域区分符，指明一个函数属于哪个类或一个数据属于哪个类。

**::** 可以不跟类名，表示全局数据或全局函数（即非成员函数）。

 

C++中函数调用非虚成员函数、调用虚函数的区别：

1.调用非虚成员函数：和调用非成员函数一样，通过对象确定对象所属的类，然后找到类的成员函数。此过程不会涉及到对象的内容，只会涉及对象的类型，是一种静态绑定。

2.调用虚函数与调用非虚成员函数不同，需同过虚函数表找到虚函数的地址，而虚函数表存放在每个对象中，不能再编译期间实现。只能在运行时绑定，是一种动态绑定。

### 访问控制      

class Base { 

public: // 公有成员 

protected: // 受保护成员 

private: // 私有成员 };

**公有**成员在程序中类的外部是可访问的。您可以不使用任何成员函数来设置和获取公有变量的值。

**私有**成员变量或函数在类的外部是不可访问的，甚至是不可查看的。只有类内和友元函数可以访问私有成员。

默认情况下，类的所有成员都是私有的。如果您没有使用任何访问修饰符，类的成员将被假定为私有成员：

**protected（受保护）**成员变量或函数与私有成员十分相似，但有一点不同，protected（受保护）成员在派生类（即子类）中是可访问的。

在下一个章节中，您将学习到派生类和继承的知识。现在您可以看到下面的实例中，我们从父类 **Box** 派生了一个子类 **smallBox**。

下面的实例与前面的实例类似，在这里 **width** 成员可被派生类 smallBox 的任何成员函数访问。

**继承中的特点**

有public, protected, private三种继承方式，它们相应地改变了基类成员的访问属性。

- 1.**public** **继承：**基类 public 成员，protected 成员，private 成员的访问属性在派生类中分别变成：public, protected, private
- 2.**protected** **继承：**基类 public 成员，protected 成员，private 成员的访问属性在派生类中分别变成：protected, protected, private
- 3.**private** **继承：**基类 public 成员，protected 成员，private 成员的访问属性在派生类中分别变成：private, private, private

但无论哪种继承方式，下面两点都没有改变：

- 1.private 成员只能被本类成员（类内）和友元访问，不能被派生类访问；
- 2.protected 成员可以被派生类访问。

 

**总结一下三种继承方式：**

| **继承方式**  | **基类的public成员** | **基类的protected成员** | **基类的private成员** | **继承引起的访问控制关系变化概括**     |
| ------------- | -------------------- | ----------------------- | --------------------- | -------------------------------------- |
| public继承    | 仍为public成员       | 仍为protected成员       | 不可见                | 基类的非私有成员在子类的访问属性不变   |
| protected继承 | 变为protected成员    | 变为protected成员       | 不可见                | 基类的非私有成员都为子类的保护成员     |
| private继承   | 变为private成员      | 变为private成员         | 不可见                | 基类中的非私有成员都称为子类的私有成员 |

 

### 构造函数和析构函数

 

C++ 类中 2 种特殊的构造函数 , 分别是 :

 

默认无参构造函数 : 如果 C++ 类中 没有定义构造函数 , C++ 编译器会自动为该类提供一个 " 默认的无参构造函数 " , 函数体为空 , 不做任何操作 ;

默认拷贝构造函数 : 如果 C++ 类中 没有定义拷贝构造函数 , C++ 编译器会自动为该类提供一个 " 默认的拷贝构造函数 " , 在函数中对成员变量进行简单的复制操作 ;

类的**构造函数**是类的一种特殊的成员函数，它会在每次创建类的新对象时执行。

构造函数的名称与类的名称是完全相同的，并且不会返回任何类型，也不会返回 void。构造函数可用于为某些成员变量设置初始值。

**带参数的构造函数**

默认的构造函数没有任何参数，但如果需要，构造函数也可以带有参数。这样在创建对象时就会给对象赋初始值，如下面的例子所示：

**使用初始化列表来初始化字段**

使用初始化列表来初始化字段：

Line::Line( double len): length(len) { }

上面的语法等同于如下语法：

Line::Line( double len) { length = len; }

但是要注意，外面先的length(len)和里面函数{}有先后顺序，先外后内

所有相同的类只有一份

可以设置默认参数

| **场景**                              | **成员最终值**                                         |
| ------------------------------------- | ------------------------------------------------------ |
| 类内默认初始化 + 无构造函数初始化列表 | 使用类内默认值（如 **hour=1**）                        |
| 类内默认初始化 + 构造函数初始化列表   | **构造函数初始化列表优先**（覆盖类内默认值）           |
| 无任何初始化                          | 成员为未定义值（基本类型）或调用默认构造函数（类类型） |

如果没有提供实参，则对象建立会自动调用无参构造函数

此时，这个无参构造函数可以叫做“默认构造函数”，不过，这个是编译器自动合成的一个无参构造函数

因为你也可以调用

如果提供了实参，对象会利用有参构造函数

 

如果没有提供任何构造函数，编译器会自动合成一个无参构造函数

无参构造函数会逐个完成类数据成员构造；对于类型为内置的数据类型、指针型的数据成员，构造时未进行初始化，也就是数值是不确定的，但存在内存，无初始化，结果具有不确定性；

对于类型为其它类类型的数据成员，会调用其他类类型的无参构造函数来完成初始化；对于数组类型的数据成员，它会执行每个数组元素对象的构造

对于类类型的数据成员。

无参构造函数会逐个完成类数据的成员构造；对于类型为内置数据类、指针数据类型，构造时未初始化，也就输数值不确定；对于其它类类型的数据成员，会调用其它类类型的无参构造函数；对于数组型数据成员，对每个数组元素对象的构造；

内置数据类型和指针类型的析构无实际动作，数组类型的成员会执行每个数据元素类型对象的析构，类类型的数据成员会执行相应类的析构函数；

对象指针本身是指针类型，不是对象，建立的时候也就不会自动建立所指类对象，不会调用构造函数；指针变量撤销时候也不会调用类的析构函数；

**1. 默认构造函数的定义**

在 C++ 中，**默认构造函数**是指 **可以不传递任何参数直接调用** 的构造函数。它可以是：

1. **无参数的构造函数**：**Clock() {}**
2. **所有参数都有默认值的构造函数**：**Clock(int h = 0, int m = 0, int s = 0) {}**

也就是说，所谓“无参构造函数”，是默认构造函数的一种

|      | **默认构造函数** | **无参构造函数** |
| ---- | ---------------- | ---------------- |
|      |                  |                  |

 

| 定义 | 能在无实参调用时使用 | 没有任何参数 |
| ---- | -------------------- | ------------ |
|      |                      |              |

 

| 示例 | Clock(int h = 0, int m = 0, int s = 0) | Clock() |
| ---- | -------------------------------------- | ------- |
|      |                                        |         |

 

C++提供专门用于构造韩素华的初始化列表机制，以冒号开始，逗号结束

C++支持对象的初始化，统一的大括号形式的初始化

内置数据类型变量采用明确的函数调用但没有给实参时，变量初始化为0

C++11支持类的一个构造函数可以在构造函数的初始化列表里委托类的其它构造函数完成初始化

Cclock::Cclock():Cclock(0,0,0){}
 支持类数据成员定义时初始化，类声明里可以用=或大括号形式初始化

构造函数初始化列表里指明的数据成员构造则放弃定义时初始化

 

1、默认无参构造函数

 

如果 C++ 类中 没有定义构造函数 , C++ 编译器会自动为该类提供一个 " 默认的无参构造函数 " , 函数体为空 , 不做任何操作 ;

 

没有定义构造函数 : 如果 没有为 C++ 类定义 构造函数 , C++ 编译器 将自动为该类 生成一个默认的无参构造函数 ;

定义了构造函数 : 如果为 C++ 类 定义了其他类型的构造函数 ( 有参构造函数 / 无参构造函数 / 拷贝构造函数 ) , C++ 编译器 将不再自动生成默认的无参构造函数 ;

 

默认构造函数内容 : C++ 编译器 为类 定义的 默认无参构造函数 , 其函数体为空 , 如下代码所示 ;

 

class MyClass { 

public: 

  int x; 

  // 默认构造函数 

  MyClass() {

  } 

};

下面的代码 , 会自动调用 默认的 无参构造函数 ;

 

MyClass obj; // 调用 默认 构造函数

AI写代码

cpp

1

2、默认拷贝构造函数

 

" 默认拷贝构造函数 " 用于创建一个新对象作为现有对象的副本 , 其作用是将 现有对象 的成员变量 复制到 新对象中 ;

 

创建一个类对象 并将其 赋值给 另一个类对象时 , 会自动调用 默认拷贝构造函数 ;

 

 

如果 C++ 类中 没有定义拷贝构造函数 , C++ 编译器会自动为该类提供一个 " 默认的拷贝构造函数 " , 在函数中对成员变量进行简单的复制操作 ;

 

没有定义拷贝构造函数 : 如果 没有为 C++ 类定义 拷贝构造函数 , C++ 编译器 将自动为该类 生成一个 默认的拷贝构造函数 ;

定义了拷贝构造函数 : 如果为 C++ 类 定义了 拷贝构造函数 , C++ 编译器 将不再自动生成默认的拷贝构造函数 ;

 

默认拷贝构造函数内容 : C++ 编译器 为类 定义的 默认拷贝构造函数 , 在函数内部将 现有对象 的 成员变量 逐个赋值给 新对象 ;

 

class MyClass { 

public: 

  int x; 

  // 默认拷贝构造函数 

  MyClass(const MyClass& other) { 

​    x = other.x; 

  } 

};

下面的代码 , 第一行代码会自动调用默认的无参构造函数 , 第二行代码会自动调用默认的拷贝构造函数 ;

 

MyClass obj;         // 调用默认无参构造函数

MyClass obj2 = obj;   // 调用默认拷贝构造函数

 

1、构造函数规则说明

 

构造函数调用规则 :

 

提供 默认无参构造函数 和 默认拷贝构造函数 : 如果 C++ 类中 没有定义 构造函数 时 , C++ 编译器 会提供 默认的 无参构造函数 和 默认的 拷贝构造函数 ;

提供 默认拷贝构造函数 : 如果 C++ 类中 , 定义了 非拷贝构造函数 , 如 : 有参构造函数 / 无参构造函数 , C++ 编译器 不会提供 默认的无参构造函数 , 但是 会提供 默认的 拷贝构造函数 ;

默认的 拷贝构造函数 只能进行 成员变量的 复制 ;

特例 : 如果 C++ 类中 , 定义了 拷贝构造函数 , 那么 C++ 编译器不会提供 默认的无参构造函数 ;

 

2、代码示例 - 只定义拷贝构造函数

 

下面的代码中 , 定义了 拷贝构造函数 , C++ 编译器不会自动生成 默认的无参构造函数 和 默认的拷贝构造函数 ;

 

使用 Student s; 代码 创建对象 , 报错 “Student”: 没有合适的默认构造函数可用 ;

 

说明 C++ 编译器没有为该类生成 默认的无参构造函数 ;

 

下面的代码中 , 定义了 有参构造函数 , C++ 编译器不会自动生成 默认的无参构造函数 和 默认的拷贝构造函数 ;

 

使用 Student s; 代码 创建对象 , 报错 “Student”: 没有合适的默认构造函数可用 ;

 

说明 C++ 编译器没有为该类生成 默认的无参构造函数 ;

int* p = new int[3](); // 值初始化：p[0]=0, p[1]=0, p[2]=0

- **()** 直接作用于 **int** 元素，触发清零。

场景    new T[n]() 的行为 内置类型成员状态

直接分配内置类型数组   所有元素值初始化为 0    不适用

分配类对象数组（默认构造）  调用默认构造函数，但不管内置类型成员是否初始化  未初始化（随机值）

分配类对象数组（显式初始化）   成员初始化为构造函数指定的值   初始化为确定值

根本原因：

值初始化（()）的粒度是 对象本身，不会递归处理对象内部的成员变量，除非构造函数显式初始化它们。

  Clock() {}  // 默认构造函数

  ~Clock() {} // 析构函数

提供了默认构造函数Clock (){}

Int *p=new Clock也会为脏数据

如果没有显示的默认构造函数

会调用编译器自动构造的默认无参构造

此时int类型的话Clock *p=new Clock（）会为0

如果只是单纯的在栈上开辟空间

Clock p

那么都为脏数据

**一、四种构造场景对比表**

| **场景**                             | **代码示例**                    | **内置类型成员状态** | **类类型成员状态** | **标准依据**         |
| ------------------------------------ | ------------------------------- | -------------------- | ------------------ | -------------------- |
| 显式空构造   **Clock() {}**          | **new Clock**   **new Clock()** | 未初始化（脏数据）   | 调用其默认构造     | [dcl.init]/7         |
| 隐式合成构造   (无用户定义构造)      | **new Clock**                   | 未初始化             | 调用其默认构造     | [class.default.ctor] |
| 隐式合成构造   (无用户定义构造)      | **new Clock()**                 | 零初始化             | 调用其默认构造     | [dcl.init]/8         |
| 带成员初始化   **Clock():hour(0){}** | 任意创建方式                    | 按指定值初始化       | 调用其默认构造     | [class.base.init]    |
|                                      |                                 |                      |                    |                      |

 

- **new Clock**：调用隐式合成的默认构造，不初始化内置类型
- **new Clock()**：触发值初始化（zero-initialization）
  - 先对所有成员进行零初始化
  - 然后调用隐式默认构造（但对已零初始化的内置类型无影响）

POD 类型（plain old data 类型的类）行为略有区别：

表达式  行为

new Clock   默认初始化（成员变量未初始化，脏数据）

new Clock()  值初始化（成员变量先被零初始化，再调用默认构造函数 —— 但此时默认构造函数是空的）

 

**类的析构函数**

类的**析构函数**是类的一种特殊的成员函数，它会在每次删除所创建的对象时执行。

析构函数的名称与类的名称是完全相同的，只是在前面加了个波浪号（~）作为前缀，它不会返回任何值，也不能带有任何参数。析构函数有助于在跳出程序（比如关闭文件、释放内存等）前释放资源。

一个类内可以有多个构造函数，可以是一般类型的，也可以是带参数的，相当于重载构造函数，但是析构函数只能有一个。

一般需要动态分配内存等资源的类需要定义析构函数、显示释放资源

内置数据类型和指针类型的析构无实际动作

数组类型的数据成员会执行每个数据元素类型对象的析构

类类型的数据成员会执行相应类的析构函数

指针不需要析构函数

 

### 一些其他问题

 

**1. 构造函数的本质**

构造函数的作用是 **初始化对象**，而不是传值。当创建一个新对象时：

- 构造函数负责设置对象的初始状态
- 参数传递是通过函数调用的常规方式（可以是传值、传引用等）
- **关键点**：构造函数是在对象内存分配 **之后** 执行的初始化操作

**示例说明**：

class Clock {

public:

  *//* *构造函数：初始化对象状态*

  Clock(int h, int m, int s) : hour(h), minute(m), second(s) {}

private:

  int hour, minute, second;

};

 

int main() {

  Clock c(12, 0, 0); *// 1.**分配内存 2.调用构造函数初始化*

}

这里 **Clock(12, 0, 0)** 不是"传值给对象"，而是在对象构造阶段用这些参数初始化其成员。

同时初始化

Clock p[2] = {{1, 2, 3}, {4, 5, 6}};

Clock p[2] = {Clock{1, 2, 3}, Clock{4, 5, 6}};

Clock *p = new Clock[2]{{1,2,3},{4,5,6}}; 应该是一样的吧！

 

### New（）的初始化

New clock[]和new clock[]()的区别

在 C++ 中，这两种写法的主要区别在于**初始化方式**：

**New Clock[2];**
 这会对数组中的每个对象进行**默认初始化**。

- 如果 Clock 是一个具有自定义默认构造函数的类，则会调用该构造函数。
- 如果 Clock 是一个 POD 类型（或没有定义构造函数），其数据成员不会被自动初始化，可能包含未定义的值。

**new  Clock[2]();**
 这会对数组中的每个对象进行**值初始化**。

- 对于类类型，若存在自定义默认构造函数，依然会调用该构造函数；
- 对于 POD 类型（或没有用户提供构造函数），值初始化会导致成员被**零初始化**（例如整数类型会被初始化为 0）。

如果构造函数中如果没有显式对成员进行初始化，则这些成员可能包含未定义的值。

·    如果是 **new int**，分配的 **int** 是**未初始化的**（值不确定，可能是垃圾值）。

·    如果是 **new int()** 或 **new int{}**，会**值初始化**（默认 **0**）。

 

### 类的内联函数

**1、引入 inline 关键字的原因**

在 c/c++ 中，为了解决一些频繁调用的小函数大量消耗栈空间（栈内存）的问题，特别的引入了 **inline** 修饰符，表示为内联函数。

栈空间就是指放置程序的局部数据（也就是函数内数据）的内存空间。

在系统下，栈空间是有限的，假如频繁大量的使用就会造成因栈空间不足而导致程序出错的问题，如，函数的死循环递归调用的最终结果就是导致栈内存空间枯竭。

其实，在内部的工作就是在每个 **for** 循环的内部任何调用 **dbtest(i)** 的地方都换成了 **(i%2>0)?"****奇":"偶"**，这样就避免了频繁调用函数对栈内存重复开辟所带来的消耗。

**2、inline使用限制**

**inline** 的使用是有所限制的，inline 只适合函数体内代码简单的函数使用，不能包含复杂的结构控制语句例如 while、switch，并且不能内联函数本身不能是直接递归函数（即，自己内部还调用自己的函数）。

**3、inline仅是一个对编译器的建议**

**inline** 函数仅仅是一个对编译器的建议，所以最后能否真正内联，看编译器的意思，它如果认为函数不复杂，能在调用点展开，就会真正内联，并不是说声明了内联就会内联，声明内联只是一个建议而已。

**4、建议 inline 函数的定义放在头文件中**

其次，因为内联函数要在调用点展开，所以**编译器必须随处可见内联函数的定义**，要不然就成了非内联函数的调用了。所以，这要求每个调用了内联函数的文件都出现了该**内联函数的定义**。

因此，将**内联函数的定义**放在**头文件**里实现是合适的，省却你为每个文件实现一次的麻烦。

**声明跟定义要一致**：如果在每个文件里都实现一次该内联函数的话，那么，最好保证每个定义都是一样的，否则，将会引起未定义的行为。如果不是每个文件里的定义都一样，那么，编译器展开的是哪一个，那要看具体的编译器而定。所以，最好将**内联函数定义**放在**头文件**中。

5、内联函数最终展开还是传统函数调用由编译器决定，一般限定内联函数不可递归，不可含循环

 

如果在类内声明的时候加上inline，那么在外部定义的时候就不必加上inline；

但如果在类内声明的时候不加上inline，那么在外部的时候必须加上inline才能作为内联函数；

但直接在类内定义，默认加上inline为内联函数

 

声明≠定义

**inline 是一种用于实现的关键字**

class A

{

  public:void Foo(int x, int y) { } // 自动地成为内联函数

}

将成员函数的定义体放在类声明之中虽然能带来书写上的方便，但不是一种良好的编程风格，上例应该改成：

// 头文件

class A

{

  public:

  void Foo(int x, int y);

}

// 定义文件

inline void A::Foo(int x, int y){} 

关键字 inline 必须与函数定义体放在一起才能使函数成为内联，仅将inline 放在函数声明前面不起任何作用。

而如下风格的函数Foo 则成为内联函数：

void Foo(int x, int y);

inline void Foo(int x, int y) {} // inline 与函数定义体放在一起

### 拷贝控制

对象传递设计对象的复制、复制、转移和销毁，通过类拷贝控制函数

拷贝控制函数由类的拷贝构造、拷贝复制、移动构造、移动赋值和析构函数组成

C++传递对象的地址时，形参本质上时实参的别名，实参是对象名，实参和形参是同一个对象。

Cset Union(const Cset &rhs)

C=A.Union(B)

C++函数传递对象的地址，形参是类指针类型，实参是对象低地址，形参指向实参代表的uix

Cset Uion (const Cset * pSet)

C=A.Union(&B)

C++传递对象数组时，形参实际是实参掉膘数组的其实地址

C++函数出纳你的对象的复制副本，实参是对象名，形参是在运行栈上根据实参对象新复制构造的对象，构造完成后，形参和实参是两个独立的对象，形参变化时，实参不变

Void dosomething (Csample obj);

Dosomething(obj);

函数的返回值也有返回对象引用、对象指针和对象值三种类型。对于局部对象，由于函数执行完毕后局部对象会析构，因此不可返回局部对象的引用或指针

当函数返回对象值类型，避难一起会通过复制构造一个匿名对象（副本对象）返回，因此函数返回值具有对象类型时，函数可以返回局部对象

然后根据这个副本对象再次（复制构造）一个新对象

可能还需要显示根据对象A复制构造一个新对象B

Csample B（A）

Csample B{A}

Csample B=A

成员子对象也会复制构造

系统会提供默认的拷贝构造函数和拷贝赋值函数

合成复制构造函数实际效果时逐个成员数据的复制

 

类似也需要队对象赋值

CSAmple A.B

B=A

对象的赋值运算符是通过赋值运算符完成的

如果一个类所有数据类型成员都是内置了数据类型、固定大小数组或类类型，无需特殊处理

 

#### 拷贝构造函数

是一种特殊的构造函数，它在创建对象时，是使用同一类中之前创建的对象来初始化新创建的对象。拷贝构造函数通常用于：

- 通过使用另一个同类型的对象来初始化新创建的对象。
- 复制对象把它作为参数传递给函数。
- 复制对象，并从函数返回这个对象。

如果在类中没有定义拷贝构造函数，编译器会自行定义一个。如果类带有指针变量，并有动态内存分配，则它必须有一个拷贝构造函数。

- 确保 **display** 内的 **obj** 和 **main** 中的 **line** 的 **ptr** 指向**不同的内存地址**（避免浅拷贝问题）。

在这里，**obj** 是一个对象引用，该对象是用于初始化另一个对象的。

 

拷贝构造函数的最常见形式如下：

classname (const classname &obj) { // 构造函数的主体 }

Line::Line(const Line &obj)

{

  cout << "调用拷贝构造函数并为指针 ptr 分配内存" << endl;

  ptr = new int;

  *ptr = *obj.ptr; // 拷贝值

}

void display(Line obj)

{

  cout << "line 大小 : " << obj.getLength() <<endl;

}

 

// 程序的主函数

int main( )

{

  Line line(10);

 

  display(line);

 

  return 0;

}

因为obj是通过值传递的，因此直接通过拷贝构造函数初始化形参 obj。

// 程序的主函数

int main( )

{

  Line line1(10);

 

  Line line2 = line1; // 这里也调用了拷贝构造函数

 

  display(line1);

  display(line2);

 

  return 0;

}

默认的拷贝构造函数实现的只能是浅拷贝，即直接将原对象的数据成员值依次复制给新对象中对应的数据成员，并没有为新对象另外分配内存资源。

这样，如果对象的数据成员是指针，两个指针对象实际上指向的是同一块内存空间。

在某些情况下，浅拷贝回带来数据安全方面的隐患。

**什么情况使用拷贝构造函数：**

类的对象需要拷贝时，拷贝构造函数将会被调用。以下情况都会调用拷贝构造函数：

- （1）一个对象以值传递的方式传入函数体
- （2）一个对象以值传递的方式从函数返回
- （3）一个对象需要通过另外一个对象进行初始化。

函数参数为 对象的引用时，不会调用拷贝构造函数:

#### 拷贝赋值

就像其他运算符一样，您可以重载赋值运算符（ = ），用于创建一个对象。

下面的实例演示了如何重载赋值运算符。

Cset & operator =（const Cset &rhs）

赋值运算符完成后返回对象的引用，使我们可以连续赋值

   void operator=(const Distance &D )

   { 

​     feet = D.feet;

​     inches = D.inches;

   }

D1=D2等同于D1.operator=(D2)

  Colour& operator =(const Colour& right)

  {

​    if (this == &right)

​    {

​      return *this;

​    }

​    this->r = right.r;

​    this->g = right.g;

​    this->b = right.b;

​    return *this;

  }

 

#### 移动赋值

 

A事后无需使用，先释放B对象的链表，再将A对象转移给B对象，A对象指针置nullptr

消失时析构函数不再释放链表

C++右值引用&&与原赋值引用&左值引用尽心区分 无const修饰

  

  *//* *移动赋值运算符*

  String& operator=(String&& other) noexcept {

​    if (this != &other) {

​      delete[] data; *//* *释放当前资源*

​      

​      *//* *窃取资源*

​      data = other.data;

​      length = other.length;

​      

​      *//* *将被移动对象置为空状态*

​      other.data = nullptr;

​      other.length = 0;

​    }

​    return *this;

  }

  

 

 

-  std::move将左值转换为右值引用
-  **移动构造函数不能接受const左值引用参数**
-  移动操作可以避免不必要的深拷贝
-  std::unique_ptr支持移动语义

具有普通名字的普通对象，采用拷贝构造或拷贝复制

 

如果需要移动构造或者移动复制

可用cstd::Move

Cset tmp=std::move(A)

A=STD::move()B

B=std;:Move(A)

 

关于std::forward的正确使用场景是

-  将左值强制转换为右值 错误
-  **完美转发函数参数时保留值类别**
-  替代std::move用于移动语义 错误
-  用于基本类型的类型转换 错误

 

#### 移动构造

Cset C=A.Unio(B)

Cset temp=A；

A=B;

B=temp；

拷贝构造

拷贝赋值

拷贝复制

极大地降低了执行效率

A对象指针置nullptr

消失时析构函数不再是放链表

C++11用右值引用&&与原引用&（左值引用）进行区分

无const修饰

后面又noexcept声明，用来不抛出异常

移动构造函数的实现代码，注意移动构造后必须保证被移动的对象将来的正确析构，一般也应该保证被移动对象将将来可重新赋值

class MyClass {

public:

  *//* *移动构造函数*

  MyClass(MyClass&& other) noexcept {

​    *//* *窃取other的资源*

​    this->data = other.data;

​    this->size = other.size;

​    

​    *//* *将other置为有效但空的状态*

​    other.data = nullptr;

​    other.size = 0;

  }

  

private:

  int* data;

  size_t size;

};

**被移动对象的状态要求**

1. **被移动对象**：参数**other**就是被移动的对象
2. **必须保证被移动对象能正确析构**：
   - 将被移动对象的指针成员置为**nullptr**
   - 将被移动对象的基本类型成员置为默认值(如0)
3. **应该保证被移动对象可重新赋值**：
   - 被移动后对象应该处于"空但有效"的状态
   - 这样后续可以对其赋值或调用其他成员函数而不会崩溃

**为什么复制赋值（Copy Assignment）通常比移动赋值（Move Assignment）多一个 Cset tmp(rhs)？**

在 C++ 中，**复制赋值运算符（operator=）** 和 **移动赋值运算符（operator= 带 &&）** 的实现方式不同，其中一个关键区别是：

- **复制赋值** 通常需要先创建一个临时副本（**tmp**），再交换资源，以确保异常安全（**strong exception safety**）。
- **移动赋值** 直接“窃取”资源，不需要临时副本，因为被移动的对象（**rhs**）之后不再需要其数据。



**1. 复制赋值（Copy Assignment）的标准实现**

**为什么需要 Cset tmp(rhs)？**

cpp

复制

下载

Cset& operator=(const Cset& rhs) {

  if (this != &rhs) {

​    Cset tmp(rhs);   *// (1)* *先构造一个临时副本*

​    swap(tmp);     *// (2)* *交换当前对象和副本的资源*

  }            

  return *this;      *// (3) tmp* *析构时自动清理旧资源*

}

**作用**：

1. **异常安全**：如果 **rhs** 的拷贝构造可能抛出异常（如内存分配失败），**tmp** 的构造失败不会影响当前对象的状态。
2. **资源管理**：**swap(tmp)** 保证当前对象获得新资源，而旧资源由 **tmp** 在析构时自动释放（RAII 机制）。
3. **避免自赋值问题**：即使 **this == &rhs**，也能正确工作（因为先拷贝再交换）。



**2. 移动赋值（Move Assignment）的标准实现**

**为什么不需要 tmp？**

cpp

复制

下载

Cset& operator=(Cset&& rhs) noexcept {

  if (this != &rhs) {

​    delete[] data;   *// (1)* *直接释放当前资源*

​    data = rhs.data;  *// (2)* *窃取 rhs 的资源*

​    size = rhs.size;

​    rhs.data = nullptr; *// (3)* *置空 rhs，防止重复释放*

​    rhs.size = 0;

  }

  return *this;

}

**区别**：

1. **直接窃取资源**：移动赋值无需拷贝，直接接管 **rhs** 的资源（高效）。
2. **无需异常安全**：移动操作通常标记为 **noexcept**，因为不分配新资源（仅指针交换）。
3. **被移动对象置空**：**rhs** 的资源被“掏空”，但仍需保持可析构状态（如 **nullptr**）。



**3. 关键对比**

| **特性**             | **复制赋值 (operator=(const Cset&))** | **移动赋值 (operator=(Cset&&))**   |
| -------------------- | ------------------------------------- | ---------------------------------- |
| **是否需要临时副本** | 是 (**Cset tmp(rhs)**)                | 否（直接窃取资源）                 |
| **异常安全性**       | 强异常安全（拷贝失败不影响原对象）    | 通常 **noexcept**（无分配操作）    |
| **资源管理**         | 通过 **swap** 自动清理旧资源          | 直接接管 **rhs** 的资源            |
| **自赋值处理**       | 自动处理（**tmp** 隔离）              | 需显式检查 (**if (this != &rhs)**) |

 

### 友元函数

 

类的友元函数是定义在类外部，但有权访问类的所有私有（private）成员和保护（protected）成员。尽管友元函数的原型有在类的定义中出现过，但是友元函数并不是成员函数。

友元可以是一个函数，该函数被称为友元函数；友元也可以是一个类，该类被称为友元类，在这种情况下，整个类及其所有成员都是友元。

如果要声明函数为一个类的友元，需要在类定义中该函数原型前使用关键字 **friend**，如下所示：

class Box

{

  double width;

public:

  double length;

  friend void printWidth( Box box );

  void setWidth( double wid );

};

声明类 ClassTwo 的所有成员函数作为类 ClassOne 的友元，需要在类 ClassOne 的定义中放置如下声明：

friend class ClassTwo;

友元函数，不属于这个类的成员函数

 

友元函数还可以是另一个类中的成员函数

在Cspouse中

{void show () const}

在Cperson中

Class Cperson

{Friend void Cspouse ::Show() const;}

即声明了Cspuse的成员函数Show（）为类Cpeson的友元函数

 

在正式声明一个类以后，才能去定义类对象

在类Cspouse的数据成员中，不能直接用Cpseon定义对象作为数据成员，只能用Cperson的指针作为数据成员

Cperson husband

Cperson wife

编译报错，因为定义对象时需要为这些对象分配存储空间

友元类

可以将一个类声明为另一个类的友元类。如将B类声明A类的友元类，意味着友元类B中的所有成员函数都是A类的友元函数，可以访问A类中的所有成员

 

### const成员函数

1. const 成员函数的定义

语法：fun() const 确实是 const 成员函数的声明方式。

 

cpp

class MyClass {

public:

  void nonConstFunc() { /* 可修改成员 */ }

  void constFunc() const { /* 不可修改成员 */ }

};

 

默认情况：const 成员函数 不能修改非静态成员变量（直接修改会编译报错）。

 

cpp

class MyClass {

  int value;

public:

  void constFunc() const {

​    value = 42; // 错误！不能修改非静态成员

  }

};

如果成员变量被声明为 mutable，则可以在 const 成员函数中修改：

 

cpp

class MyClass {

  mutable int counter; // 可被 const 函数修改

public:

  void constFunc() const {

​    counter++; // 合法

  }

};

 

.const 对象只能调用 const 成员函数

规则：const 对象（如 const MyClass obj;）只能调用 const 成员函数。

 

cpp

const MyClass obj;

obj.constFunc();  // 合法

obj.nonConstFunc(); // 错误！const 对象不能调用非 const 函数

不能直接调用：const 成员函数内部 不能直接调用非 const 成员函数，因为非 const 函数可能修改成员变量，违反 const 语义。

 

cpp

class MyClass {

public:

  void nonConstFunc() { /* 修改成员 */ }

  void constFunc() const {

​    nonConstFunc(); // 错误！const 函数不能调用非 const 函数

  }

};

绕过限制（不推荐）：

 

通过 const_cast 移除 this 的 const 属性（危险，破坏设计初衷）：

 

void constFunc() const {

  const_cast<MyClass*>(this)->nonConstFunc(); // 强制调用，不推荐！

}

 

不能修饰非成员函数：全局函数或静态成员函数不能用 const 修饰。

问题    答案

const 成员函数语法  void func() const;

能否修改非静态成员变量？   默认不能，除非变量是 mutable

const 对象可调用的函数  只能调用 const 成员函数

const 函数能否调用非 const 函数？   不能（除非强制 const_cast，不推荐）

const 能否修饰成员函数？ 可以，且是 const 成员函数的唯一声明方式

 

 

### 对象数组和动态对象

#### 对象数组

对象数组建立时为每个蒜素对象自动调用构造函数 数组撤销时为数组的每个元素对象调用析构函数

数组元素连续存放

 

#### 对象指针和动态生成对象

一个指向 C++ 类的指针与指向结构的指针类似，访问指向类的指针的成员，需要使用成员访问运算符 **->**，就像访问指向结构的指针一样。与所有的指针一样，您必须在使用指针之前，对指针进行初始化。

在 C++ 中，指向类的指针指向一个类的对象，与普通的指针相似，指向类的指针可以用于访问对象的成员变量和成员函数。

对象指针是指针类型；指针变量建立时不会自动建立所指类对象，也不会调用对象类的构造函数

指针变量撤销时也不会自动删除所指对象，不会调用对象类的析构函数

**动态分配内存**

指向类的指针还可以用于动态分配内存，创建类的对象：

**1. 默认行为的问题**

如果 **Clock** 类 **没有默认构造函数**（即所有构造函数都需要参数），直接使用 **new Clock[n]** 会编译报错：

class Clock {

public:

  Clock(int h, int m, int s) {} *//* *只有带参构造函数*

};

 

int main() {

  Clock* p = new Clock[10]; *//* *错误！需要默认构造函数*

}

- **原因**：**new[]** 会尝试调用默认构造函数（无参构造函数）初始化数组中的每个元素。

**方法 1：为类添加默认构造函数**

class Clock {

public:

  Clock() {} *//* *添加默认构造函数*

  Clock(int h, int m, int s) {} *//* *原有带参构造函数*

};

 

int main() {

  Clock* p = new Clock[10]; *//* *合法，调用默认构造函数*

}

- **缺点**：可能需要为成员变量设置默认值（如 **hour=0, minute=0, second=0**）。

**3. 为什么 new[] 不支持直接传递参数？**

- **语言设计限制**：**new[]** 的语法设计为统一初始化数组元素，无法为每个元素单独指定参数。
- **替代方案**：使用 **std::vector** 或手动内存管理。

在C++11中引入了**列表初始化（List Initialization）**，允许你用花括号 {} 来初始化数组，甚至在 new 动态分配数组时也可以用。

Clock *p = new Clock[2]{{0,0,0}, {1,1,1}};

静态数组定义：Clock arr[2] = {{1,1,1}, {0,0,0}};

**替代写法（通用、兼容性好）：**

Clock* p = new Clock[2];

p[0] = Clock(0, 0, 0);

p[1] = Clock(1, 1, 1);

或者用 std::vector（推荐现代C++写法）：

\#include <vector>

vector<Clock> clocks = { {0, 0, 0}, {1, 1, 1} };

 

动态分配对象时，先在对上申请直接占用的内存空间，再申请得到的内存空间上执行构造函数

动态分配对象数组时，先在堆上申请n个对象的数组直接占用的连续空间，再在申请得到的内存空间上为每个对象分别执行构造函数

如果类对象构造本身需要动态分配，则构造函数过程中也会再次动态申请空间

如果申请失败，抛出异常

删除单个对象时，先执行对象类的析构函数，再释放对象直接占用的空间。

删除对象数组时先执行数组里每个对象的析构函数，再释放对象数组直接占用的空间

**指向类的指针作为函数参数**

指向类的指针可以作为函数参数传递：

\#include <iostream>

 

class MyClass {

public:

  int data;

 

  void display() {

​    std::cout << "Data: " << data << std::endl;

  }

};

 

// 函数接受指向类的指针作为参数

void processObject(MyClass *ptr) {

  ptr->display();

}

 

int main() {

  MyClass obj;

  obj.data = 42;

 

  // 将指向类的指针传递给函数

  processObject(&obj);

 

  return 0;

}

#### 对象引用

引用必须在建立时初始化，引用可以作为左值。被引用对象类型可以是基本数据类型和指针类型，也可以是类类型

 

默认的复制行为是逐个数据成员的复制，默认的赋值行为是逐个数据成员的赋值

大型对象的复制和赋值会产生严重的性能开销，传递引用比传递对象的指针更直观

C++函数返回值返回对象引用，必须确保被引用对象的存在，函数不可返回局部对象的引用，局部对象采用传值方式返回时，编译器内部会再完成局部对象的复制后返回，不会产生问题

Cset Union(const Cset &rhs) const;

表示返回集合对象，函数原型中最后的const明确并运算过程中当前集合对象不会被改变，rhs常引用， 再运算过程中不会被改变，结果保存在成员函数Union内局部对象，结束时返回结果集。

不可返回函数内局部对象的引用或指针

#### this 指针

在 C++ 中，**this** 指针是一个特殊的指针，它指向当前对象的实例。

在 C++ 中，每一个对象都能通过 **this** 指针来访问自己的地址。

**this**是一个隐藏的指针，可以在类的成员函数中使用，它可以用来指向调用对象。

当一个对象的成员函数被调用时，编译器会隐式地传递该对象的地址作为 this 指针。

友元函数没有 **this** 指针，因为友元不是类的成员，只有成员函数才有 **this** 指针。

P1.set(0,0,0)=set (const Clock *this(&P),0,0,0)

#### 类成员作用域和生存期

类成员作用域再该定义内和类成员函数定义内游侠，公有成员再类外可通过对象成员或者对象指针访问

类数据成员和成员函数形参同名时，根据最小作用域原则，函数体内同名对象默认代表形参，如果需要访问同名类数据成员，则可以通过类名“”成员或通过this->指针访问类的成员

This->m_iSecond=m_iSecond

Cclock::m_iSecond=m_iSecond 

### 静态成员和静态成员函数

![img](data:image/png;base64,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)

#### 静态成员

Staic 类型名 数据成员吗

static int objectCount;

无论建立多少个该类的对象，都只有一个静态数据成员的存储空间

静态数据成员的访问权限与普通数据成员相同，也分为公有、保护、私有

在类外只能访问公有静态数据成员

访问方式为

类名：：静态数据成员名

静态成员在类的所有对象中是共享的。静态成员必须要有显示的初始化语句，要不然编译器无法通过.我们不能把静态成员的初始化放置在类的定义中，但是可以在类的外部通过使用范围解析运算符 **::** 来重新声明静态变量从而对它进行初始化，如下面的实例所示。静态成员变量在类中仅仅是声明，没有定义，所以要在类的外面定义，实际上是给静态成员变量分配内存。如果不加定义就会报错，初始化是赋一个初始值，而定义是分配内存。

在类内可以直接访问所有点静态数据成员，类的静态数据成员必须在类外进行

// 初始化类 Box 的静态成员

 int Box::objectCount = 0;

如果只声明了类而未定义对象，则为静态数据成员分配存储空间。

静态放在初始化列表

A::A(int i):a(i){}

初始化const成员

A由构造函数初始化，不能有ai

为什么？

Static const b如何初始化？

根据static来定义，static const b;const int A：：b=10

This 指针常量 常引用做形参

有指针变量成员函数 构造函数必须new 一个完成空间分配

 

静态成员函数不能访问非静态成员函数

常饮用雷西那个

不能共享一个内存

把形参作为引用，避免了局部作用域 引用没对象的情况

即int &func (int &x){return x}

而非int & func{int a;returna}

类里面由指针

在析构函数里delete

#### 以下类型的成员必须在构造函数的初始化列表中初始化

在C++中，**以下类型的成员必须在构造函数的初始化列表中初始化**，而不能在构造函数体内赋值：

1. **const成员**

cpp

复制

下载

class Person {

  const int id;

public:

  Person(int i) : id(i) {} *//* *必须初始化列表*

};

1. **引用成员**

cpp

复制

下载

class Person {

  int& ref;

public:

  Person(int& r) : ref(r) {} *//* *必须初始化列表*

};

1. **没有默认构造函数的类类型成员**

cpp

复制

下载

class Date {

public:

  Date(int y, int m, int d); *//* *没有默认构造函数*

};

 

class Person {

  Date birthday;

public:

  Person(int y, int m, int d) : birthday(y, m, d) {} *//* *必须初始化列表*

};

1. **基类没有默认构造函数时**

 

 

**静态成员初始化**

静态成员变量需要在类外进行初始化：

cpp

复制

下载

class A {

  static const int b; *//* *声明*

};

const int A::b = 10;  *//* *定义并初始化*

**const 成员初始化**

const 成员必须在构造函数初始化列表中初始化：

cpp

复制

下载

class A {

  const int a;

public:

  A(int i) : a(i) {} *//* *正确：在初始化列表中初始化const成员*

  *// A(int i) { a = i; } //* *错误：不能在构造函数体内赋值*

};

**this 指针**

this 指针是一个指针常量，指向当前对象实例。

**常引用作为形参**

使用常引用作为形参可以避免不必要的拷贝：

cpp

复制

下载

void func(const MyClass& obj) {

  *//* *可以读取obj但不能修改*

}

**指针成员与动态内存分配**

当类包含指针成员时，通常需要：

1. 在构造函数中使用 new 分配内存
2. 在析构函数中使用 delete 释放内存
3. 考虑实现拷贝构造函数和赋值运算符（Rule of Three）

cpp

复制

下载

class MyClass {

  int* ptr;

public:

  MyClass(int size) { ptr = new int[size]; }

  ~MyClass() { delete[] ptr; }

  *//* *还需要实现拷贝构造函数和赋值运算符*

};

**静态成员函数**

静态成员函数只能访问静态成员，不能访问非静态成员：

cpp

复制

下载

class A {

  static int s;

  int ns;

public:

  static void staticFunc() { 

​    s = 10;  *//* *正确*

​    *// ns = 10; //* *错误：不能访问非静态成员*

  }

};

**引用返回注意事项**

返回引用时要确保引用对象在函数返回后仍然存在：

cpp

复制

下载

int& goodFunc(int& x) { return x; } *//* *正确：返回传入的引用*

 

int& badFunc() {

  int a = 10;

  return a; *//* *错误：返回局部变量的引用*

}

- const 成员一旦定义，**必须在对象创建时就完成初始化**；
- 构造函数体内已经晚了，编译器在进入函数体时成员已经初始化完成；
- 初始化列表正好是在对象构造阶段初始化成员的唯一机会。

 

#### 静态成员函数

如果把函数成员声明为静态的，就可以把函数与类的任何特定对象独立开来。静态成员函数即使在类对象不存在的情况下也能被调用，**静态函数**只要使用类名加范围解析运算符 **::** 就可以访问。

静态成员函数只能访问静态成员数据、其他静态成员函数和类外部的其他函数。

静态尘缘函数直属于类

静态成员函数有一个类范围，他们不能访问类的 this 指针。您可以使用静态成员函数来判断类的某些对象是否已被创建。

声明方式

 Static return_type func_name (paramert)

在类外调用静态成员函数

类名：：静态成员函数名（实参版）

**静态成员函数与普通成员函数的区别：**

- 静态成员函数没有 this 指针，只能访问静态成员（包括静态成员变量和静态成员函数）。
- 普通成员函数有 this 指针，可以访问类中的任意成员；而静态成员函数没有 this 指针。

对类中静态变量的初始化始终令人迷惑不解。在这总结分享一下。

**类中特殊成员变量的初始化问题：**

- 常量变量：必须通过构造函数参数列表进行初始化。
- 引用变量：必须通过构造函数参数列表进行初始化。
- 普通静态变量：要在类外通过"::"初始化。
- 静态整型常量：可以直接在定义的时候初始化。
- 静态非整型常量：不能直接在定义的时候初始化。要在类外通过"::"初始化。

 

 

Mutable 和volatil

即使是常对象、长成员函数也可以修改它的值

Void show() const

{

 

++count}

Private: :
 mutable int count

Volatile

 

### 类的嵌套定义

内部类名时外部类的类型成员，可直接使用的有效范围时外部类，在其他地方使用，需要在内部类名前添加外部类名：：

外部类名：：内部类名

在类外定义函数也需要

外部类名：：内部类名：：成员函数名 函数体

 

### 集合类

Enum{MaxSIZE=100}

这段代码定义了一个**匿名枚举类型**，里面只有一个枚举常量：

- MaxSIZE 是一个整型常量；
- 它的值是 100；
- 它的类型其实是 int（因为枚举默认底层类型为 int）。

所以，等价于你写了：

cpp

复制编辑

const int MaxSIZE = 100;

### ：：与：的区别

**1. :: 的用途**

**::** 主要用于访问 **类作用域** 或 **命名空间作用域** 中的成员，包括：

- **静态成员变量/函数**（属于类本身，而非对象）
- **嵌套类型**（如嵌套类、枚举）
- **被派生类覆盖的基类成员**（需要显式指定基类作用域）
- **全局作用域**（如 **::global_var**）

**示例场景：**

cpp

复制

下载

class Base {

public:

  static int static_var; *//* *静态成员*

  int instance_var;    *//* *实例成员*

  void func() {}     *//* *实例成员函数*

};

 

int Base::static_var = 10; *//* *静态成员必须在类外定义*

 

class Derived : public Base {

public:

  int instance_var = 20; *//* *覆盖基类的同名成员*

 

  void show() {

​    cout << Base::instance_var; *//* *用::访问基类被覆盖的成员*

​    cout << Base::static_var;  *//* *用::访问静态成员*

  }

};

**关键点**：
 只要访问的是 **类作用域内的成员**（而非对象成员），就必须用 **::**，例如：

- 静态成员（属于类）
- 被覆盖的基类成员（需显式指定基类作用域）
- 嵌套类型（如 **Outer::Inner**）



**2. . 的用途**

**.** 用于访问 **对象实例的成员**（非静态成员变量/函数）：

cpp

复制

下载

Base obj;

obj.instance_var = 5; *//* *访问实例成员变量*

obj.func();      *//* *调用实例成员函数*

**关键点**：
 如果成员属于某个对象实例（非静态），就必须用 **.**（或 **->** 如果是指针）。



**3. 为什么被覆盖的基类成员要用 ::？**

当派生类定义了与基类同名的成员时，默认会 **隐藏（hide）** 基类的成员。此时：

- 直接写 **x** 访问的是派生类的成员。
- 如果要访问 **基类的同名成员**，必须显式指定基类作用域（**Base::x**），因为基类的成员已被隐藏，不再属于当前对象的作用域。

**类比理解：**

- 静态成员属于类作用域 → 用 **::**
- 被覆盖的基类成员属于基类作用域 → 也用 **::**
- 实例成员属于对象 → 用 **.**



**4. 静态成员 vs. 被覆盖成员**

| **场景**         | **为什么用 ::？**                    | **示例**               |
| ---------------- | ------------------------------------ | ---------------------- |
| 静态成员         | 属于类作用域，而非对象               | **Base::static_var**   |
| 被覆盖的基类成员 | 基类成员被隐藏，需显式指定基类作用域 | **Base::instance_var** |



**5. 总结**

| **运算符** | **用途**                       | **示例**                   |
| ---------- | ------------------------------ | -------------------------- |
| **::**     | 访问 **类/基类/命名空间** 成员 | **Base::x**, **std::cout** |
| **.**      | 访问 **对象实例** 的成员       | **obj.x**, **obj.func()**  |

**核心规则**：

- 用 **::** 访问 **类作用域内** 的成员（静态成员、被覆盖的基类成员、嵌套类型）。
- 用 **.** 访问 **对象实例** 的成员（非静态成员变量/函数）。

 

## 运算符重载

 

T1.oprator+(t2)

Oprator+(t1,t2)

T1+t2

做出对象：调用对象

右侧对象L作为参数北川金

**C++ 重载运算符和重载函数**

C++ 允许在同一作用域中的某个**函数**和**运算符**指定多个定义，分别称为**函数重载**和**运算符重载**。

重载声明是指一个与之前已经在该作用域内声明过的函数或方法具有相同名称的声明，但是它们的参数列表和定义（实现）不相同。

当您调用一个**重载函数**或**重载运算符**时，编译器通过把您所使用的参数类型与定义中的参数类型进行比较，决定选用最合适的定义。选择最合适的重载函数或重载运算符的过程，称为**重载决策**。

**C++ 中的函数重载**

在同一个作用域内，可以声明几个功能类似的同名函数，但是这些同名函数的形式参数（指参数的个数、类型或者顺序）必须不同。您不能仅通过返回类型的不同来重载函数。

下面的实例中，同名函数 **print()** 被用于输出不同的数据类型

函数重载与函数的返回值无关

小数是double类型

**C++ 中的运算符重载**

您可以重定义或重载大部分 C++ 内置的运算符。这样，您就能使用自定义类型的运算符。

重载的运算符是带有特殊名称的函数，函数名是由关键字 operator 和其后要重载的运算符符号构成的。与其他函数一样，重载运算符有一个返回类型和一个参数列表。

Box operator+(const Box&);

声明加法运算符用于把两个 Box 对象相加，返回最终的 Box 对象。大多数的重载运算符可被定义为普通的非成员函数或者被定义为类成员函数。如果我们定义上面的函数为类的非成员函数，那么我们需要为每次操作传递两个参数，如下所示：

Box operator+(const Box&, const Box&);

下面的实例使用成员函数演示了运算符重载的概念。在这里，对象作为参数进行传递，对象的属性使用 **this** 运算符进行访问，如下所示：

   Box operator+(const Box& b)

   {

​     Box box;

​     box.length = this->length + b.length;

​     box.breadth = this->breadth + b.breadth;

​     box.height = this->height + b.height;

​     return box;

   }实际调用时

Box1+Box2等价于Box1.operator+(Box2)

在上述教程中，复合赋值运算符重载没有被提到，但这往往也是经常需要用到的，而且对于新人来讲比较容易出错，我来补充一下吧。

**复合赋值操作符是指 += ， \*= ， -= 这一类由基本算数运算符（ + 、 - 、 \* 、 / )或位运算符(| 、 & 、~等）加 = 号构成的运算符**。它们把左右操作数进行相应运算后的结果赋值给左操作符。例如：a += b； 意味着 a = a + b；  复合赋值操作符的返回值，默认是左值。比如a += b；中的a。

在进行复合赋值操作符重载定义的时候，需要注意，**其返回值，应该为（ \* this）<类成员>或者第一个也就是左操作数<非成员函数>**。例如：（假设已经自定义算数或位操作运算符）

className & className::operator +=(className & right)

{

  return (*this) = (*this) + right;

}

 

className& operator +=(className& left, className& right)

{

  return left = left + right;

}

**className A = a，B = b;**（A，B是对象名，a，b是值）。

**A += B;** （此时A = a + b，整个表达式返回值是a + b）。

重写复合赋值操作符的时候，一定要记得，要把运算结果赋给左值，再返回左值。如果直接返回结果，我们将不会被调用处看到左值被运算的效果。

 

  // 重载 + 运算符，用于把两个 Box 对象相加

  Box operator+(const Box& b)

  {

   Box box;

   box.length = this->length + b.length;

   box.breadth = this->breadth + b.breadth;

   box.height = this->height + b.height;

   return box;

  }

**可重载运算符/不可重载运算符**

下面是可重载的运算符列表：

| 双目算术运算符 | +  (加)，-(减)，*(乘)，/(除)，% (取模)                       |
| -------------- | ------------------------------------------------------------ |
| 关系运算符     | ==(等于)，!= (不等于)，< (小于)，> (大于)，<=(小于等于)，>=(大于等于) |
| 逻辑运算符     | \|\|(逻辑或)，&&(逻辑与)，!(逻辑非)                          |
| 单目运算符     | +  (正)，-(负)，*(指针)，&(取地址)                           |
| 自增自减运算符 | ++(自增)，--(自减)                                           |
| 位运算符       | \|  (按位或)，& (按位与)，~(按位取反)，^(按位异或),，<< (左移)，>>(右移) |
| 赋值运算符     | =,  +=, -=, *=, /= , % = , &=, \|=, ^=, <<=, >>=             |
| 空间申请与释放 | new,  delete, new[ ] , delete[]                              |
| 其他运算符     | **()**(函数调用)，**->**(成员访问)，**,**(逗号)，**[]**(下标) |

下面是不可重载的运算符列表：

- **.**：成员访问运算符
- **.\***, **->\***：成员指针访问运算符
- **::**：域运算符
- **sizeof**：长度运算符
- **?:**：条件运算符
- **#**： 预处理符号

### 一元运算符重载

一、递增运算符和递减运算符

1、递增和递减一般是改变对象的状态，所以一般是重载为成员函数。

2、重载递增递减，一定要和指针的递增递减区分开。因为这里的重载操作的是对象，而不是指针(由于指针是内置类型，指针的递增递减是无法重载的)，所以一般情况的递增递减是操作对象内部的成员变量。

3、递增和递减分为前置和后置情况，a = ++b;(前置)， a = b++;(后置)。因为符号一样，所以给后置版本加一个int形参作为区分，这个形参是0，但是在函数体中是用不到的，只是为了区分前置后置。

// 例如这里的重载递增就是为了增加pos的值

class ca

{

public:  

  int pos;

 

  //前置递增就是增加当前对象的pos的值，并且返回当前对象

  ca operator++(){

​    pos++;

​    return *this;

  }

或者 

Ca operator ++()

{

Ca temp;

Temp.pos=++pos;

Return temp;
 }

  //后置递增就是增加当前对象的pos的值，并且返回增加pos之前的该对象

  ca operator++(int){

​    ca ret = *this;

​    ++*this;    //这个会调用上面的函数，其实这里可以换成pos++;

​    return ret;

  }

或者

Ca operator ++(int )

{

Ca temp;

temp.pos=pos++;

Return temp;

}

};

 

在前缀递增时，若想要实现 **++(++a)** 这种连续自加，就要返回其对象的引用，这样才能保证操作的是同一块内存空间，否则就只是单纯的赋值操作，原来的对象并未被修改。

Complex& Complex::operator ++() {

  ++i;

  ++j;

  return *this;

}

 

二、一元减运算符

   // 重载负运算符（ - ）

   Distance operator- () 

   {

​     feet = -feet;

​     inches = -inches;

​     return Distance(feet, inches);

   }

三、逻辑非运算符

### 二元运算符重载

  // 重载 + 运算符，用于把两个 Box 对象相加

  Box operator+(const Box& b)

  {

   Box box;

   box.length = this->length + b.length;

   box.breadth = this->breadth + b.breadth;

   box.height = this->height + b.height;

   return box;

  }

当 2 个对象相加时是没有顺序要求的，但要重载 **+** 让其与一个数字相加则有顺序要求，可以通过加一个友元函数使另一个顺序的输入合法。

Public:

​      A operator+(const A & obj);

​      A operator+(const int b);

  friend A operator+(const int b, A obj); 

A A::operator +(const A& obj)//重载+号用于 对象相加 

{

  return this->a+obj.a;

}

A A::operator+(const int b)//重载+号用于 对象与数相加

{

  return A(a+b);

}

A operator+(const int b, A obj)

{

  return obj+b;//友元函数调用第二个重载+的成员函数 相当于 obj.operator+(b); 

}

关系运算符重载

   bool operator <(const Distance& d)

   {

​     if(feet < d.feet)

​     {

​      return true;

​     }

​     if(feet == d.feet && inches < d.inches)

​     {

​      return true;

​     }

​     return false;

   }

输入输出运算符重载

C++ 能够使用流提取运算符 >> 和流插入运算符 << 来输入和输出内置的数据类型。您可以重载流提取运算符和流插入运算符来操作对象等用户自定义的数据类型。

在这里，有一点很重要，我们需要把运算符重载函数声明为类的友元函数，这样我们就能不用创建对象而直接调用函数。

   friend ostream &operator<<( ostream &output, 

​                    const Distance &D )

   { 

​     output << "F : " << D.feet << " I : " << D.inches;

​     return output;      

   }

 

   friend istream &operator>>( istream &input, Distance &D )

   { 

​     input >> D.feet >> D.inches;

​     return input;      

   }

因为最后返回的还是 os，所以可以循环使用，也就是写成:

Cout <<d1<<d2

赋值运算符

用于创建一个对象，比如拷贝构造函数

   void operator=(const Distance &D )

   { 

​     feet = D.feet;

​     inches = D.inches;

   }

 

- **尽量让运算符重载的参数是类类型**（如 **operator+(const Number&)**），而不是基本类型（如 **operator+(double)**）。
- **用 explicit 防止隐式转换**，避免意外的二义性。

 

## 继承

面向对象程序设计中最重要的一个概念是继承。继承允许我们依据另一个类来定义一个类，这使得创建和维护一个应用程序变得更容易。这样做，也达到了重用代码功能和提高执行效率的效果。

当创建一个类时，您不需要重新编写新的数据成员和成员函数，只需指定新建的类继承了一个已有的类的成员即可。这个已有的类称为**基类**，新建的类称为**派生类**。

继承代表了 **is a** 关系。

### 基类 & 派生类

一个类可以派生自多个类，这意味着，它可以从多个基类继承数据和函数。定义一个派生类，我们使用一个类派生列表来指定基类。类派生列表以一个或多个基类命名，形式如下：

class derived-class: access-specifier base-class

其中，访问修饰符 access-specifier 是 **public****、protected** 或 **private** 其中的一个，base-class 是之前定义过的某个类的名称。如果未使用访问修饰符 access-specifier，则默认为 private。

### 访问控制

派生类可以访问基类中所有的非私有成员。因此基类成员如果不想被派生类的成员函数访问，则应在基类中声明为 private。

我们可以根据访问权限总结出对于一个类不同的访问类型，如下所示：

（这只是访问控制，与派生类的继承方式为什么无关，继承方式决定的从派生类对象访问继承自基类的成员时，这些成员的访问控制如何变化）

| **访问** | **public** | **protected** | **private** |
| -------- | ---------- | ------------- | ----------- |
| 同一个类 | yes        | yes           | yes         |
| 派生类   | yes        | yes           | no          |
| 外部的类 | yes        | no            | no          |

一个派生类继承了所有的基类方法，但下列情况除外：

- 基类的构造函数、析构函数和拷贝构造函数。
- 基类的重载运算符。
- 基类的友元函数。

#### 派生类是会继承父类的构造方法的，但在继承构造方法时有一些注意事项，这在 C++11 以及之后的标准中得到了支持

class Base {

public:  int x;

protected: int y;

private:  int z;

};

 

class Derived : public Base {

  // 在派生类内部：

  void foo() {

​    x; // ✅ public成员可访问

​    y; // ✅ protected成员可访问

​    z; // ❌ private成员不可访问

  }

};

 

// 外部函数

void bar() {

  Base b;

  b.x; // ✅ public成员可访问

  b.y; // ❌ protected成员不可访问

  b.z; // ❌ private成员不可访问

}

### 继承类型

**继承方式（public / protected / private）控制的是：**

**“从派生类对象访问继承自基类的成员时，这些成员的访问控制如何变化”**

 

当一个类派生自基类，该基类可以被继承为 **public****、protected** 或 **private** 几种类型。继承类型是通过上面讲解的访问修饰符 access-specifier 来指定的。

我们几乎不使用 **protected** 或 **private** 继承，通常使用 **public** 继承。当使用不同类型的继承时，遵循以下几个规则：

- **公有继承（public）：**当一个类派生自**公有**基类时，基类的**公有**成员也是派生类的**公有**成员，基类的**保护**成员也是派生类的**保护**成员，基类的**私有**成员不能直接被派生类访问，但是可以通过调用基类的**公有**和**保护**成员来访问。
- **保护继承（protected）：** 当一个类派生自**保护**基类时，基类的**公有**和**保护**成员将成为派生类的**保护**成员。
- **私有继承（private）：**当一个类派生自**私有**基类时，基类的**公有**和**保护**成员将成为派生类的**私有**成员。

**3. 继承方式**

| **基类成员访问权限** | **公有继承（public）**    | **保护继承（protected）** | **私有继承（private）** |
| -------------------- | ------------------------- | ------------------------- | ----------------------- |
| **public**           | 在派生类中仍为 **public** | 降级为 **protected**      | 降级为 **private**      |
| **protected**        | 仍为 **protected**        | 仍为 **protected**        | 降级为 **private**      |
| **private**          | **不可见**                | **不可见**                | **不可见**              |

class Base {

public:

  int a;

protected:

  int b;

private:

  int c;

};

 

class Derived_public : public Base {

  void test() {

​    a = 1; // ✅ OK

​    b = 2; // ✅ OK

​    // c = 3; // ❌ Error: private成员不能被派生类访问

  }

};

 

class Derived_protected : protected Base {

  void test() {

​    a = 1; // ✅ OK

​    b = 2; // ✅ OK

  }

};

 

class Derived_private : private Base {

  void test() {

​    a = 1; // ✅ OK

​    b = 2; // ✅ OK

  }

};

 

上面的三种继承方式在成员**“继承过来后对外可见性”**不同：

| **继承方式**                                               | **Base::a 在 Derived 中变成**    | **外部能否访问   Derived::a** |      |      |
| ---------------------------------------------------------- | -------------------------------- | ----------------------------- | ---- | ---- |
| public                                                     | public                           | ✅ 可以                        |      |      |
| protected                                                  | protected                        | ❌ 不行                        |      |      |
| private                                                    | private                          | ❌ 不行                        |      |      |
| **概念**                                                   | **控制什么？**                   |                               |      |      |
| **成员访问修饰符** /访问控制(public / protected / private) | 控制“谁能访问这个成员”           |                               |      |      |
| **继承方式**  (public / protected / private)               | 控制“这个成员在派生类中的可见性” |                               |      |      |
|                                                            |                                  |                               |      |      |

外部函数要访问类成员，必须遵守该成员的访问控制：

- public 成员：✅ 外部函数可以访问。
- protected 或 private：❌ 不能直接访问，除非是友元（friend）。

继承方式（**public**/**protected**/**private**）是基类成员在派生类中的 **最高访问权限上限**。

基类成员的最终权限 = **min(****基类成员原始权限, 继承方式)**。

 

私有继承的话，基类成员（公有、保护、私有）成为了派生类的私有成员；访问控制和派生类自己的私有成员一致

保护继承的话，基类的公有、保护成员变成了派生类的保护成员。访问控制和派生类自己的保护成员一致。

 

class Date {

public:

  Date(int y, int m, int d); *//* *没有默认构造函数*

};

 

class Person : public Date {  *// Person* *继承 Date*

public:

  *//* *必须在初始化列表中调用 Date 的构造函数*

  Person(int y, int m, int d) : Date(y, m, d) {} 

};

 

| **情况**             | **是否必须用初始化列表？** | **原因**                 |
| -------------------- | -------------------------- | ------------------------ |
| 基类没有默认构造函数 | **必须**                   | 必须显式调用基类构造函数 |
| **const** 成员       | **必须**                   | 不能赋值，只能初始化     |
| 引用成员             | **必须**                   | 必须在创建时绑定         |
| 无默认构造的类成员   | **必须**                   | 无法默认构造             |

 

### 多继承

多继承即一个子类可以有多个父类，它继承了多个父类的特性。

C++ 类可以从多个类继承成员，语法如下：

class <派生类名>:<继承方式1><基类名1>,<继承方式2><基类名2>,…

{

<派生类类体>

};

其中，访问修饰符继承方式是 **public****、protected** 或 **private** 其中的一个，用来修饰每个基类，各个基类之间用逗号分隔，如上所示。

### 虚继承

多继承(环状继承),A->D, B->D, C->(A，B)，例如：

class D{......};

class B: public D{......};

class A: public D{......};

class C: public B, public A{.....};

这个继承会使D创建两个对象,要解决上面问题就要用虚拟继承格式

格式：**class 类名: virtual 继承方式 父类名**

class D{......};

class B: virtual public D{......};

class A: virtual public D{......};

class C: public B, public A{.....};

虚继承--（在创建对象的时候会创建一个虚表）在创建父类对象的时候

A:virtual public D

B:virtual public D

**实例：**

\#include <iostream>

 

using namespace std;

//基类

 

class D

{

public:

  D(){cout<<"D()"<<endl;}

  ~D(){cout<<"~D()"<<endl;}

protected:

  int d;

};

 

class B:virtual public D

{

public:

  B(){cout<<"B()"<<endl;}

  ~B(){cout<<"~B()"<<endl;}

protected:

  int b;

};

 

class A:virtual public D

{

public:

  A(){cout<<"A()"<<endl;}

  ~A(){cout<<"~A()"<<endl;}

protected:

  int a;

};

 

class C:public B, public A

{

public:

  C(){cout<<"C()"<<endl;}

  ~C(){cout<<"~C()"<<endl;}

protected:

  int c;

};

 

int main()

{

  cout << "Hello World!" << endl;

  C c;  //D, B, A ,C

  cout<<sizeof(c)<<endl;

  return 0;

}

虚基类的最终子孙类对象只建立一份虚基类部分对象，虚基类部分对象构造方法在最终建立的ui先子孙类构造函数中指明，中间类部分对象构造时将不在构造虚基类部分对象

如果虚基类中定义有带参数的构造函数，并且参数没有默认值，且没有定义无参构造函数，则在虚基类的直接派生类和简介拍摄雷达构造函数初始化表中都需要对虚基类初始化

子类的函数会出现在初始化列表中。原因在于子类能够从基类继承的内容限制上。

我们知道，一个派生类继承了所有的基类方法，但下列情况除外：

- 基类的构造函数、析构函数和拷贝构造函数。
- 基类的重载运算符。
- 基类的友元函数。

因此，我们不能够在子类的成员函数体中调用基类的构造函数来为成员变量进行初始化。例如这样子是不可以的

// 派生类

class Rectangle: public Shape

{

  public:

   Rectangle(int a,int b)

   {

​    Shape(a,b);

   }

   

};

 

但我们可以把基类的构造函数放在子类构造函数的初始化列表上，以此实现调用基类的构造函数来为子类从基类继承的成员变量初始化。

\#include <iostream>

 

using namespace std;

 

// 基类

class Shape 

{

  public:

   Shape(int w,int h)

   {

​    width=w;

​    height=h;

   }

  protected:

   int width;

   int height;

};

 

// 派生类

class Rectangle: public Shape

{

  public:

   Rectangle(int a,int b):Shape(a,b)

   {

​    

   }

};

派生类在继承基类的成员变量时，会单独开辟一块内存保存基类的成员变量，因此派生类自己的成员变量即使和基类的成员变量重名，但是也不会引起冲突。如下代码：

\#include <iostream>

using namespace std;

 

//基类

class A

{

public:

  A(){n = 0;};

  ~A(){};

  int getA(){ return n;};

  void setA(int t){ n = t;};

 

private:

  int n;

};

 

//派生类

class B :public A

{

public:

  B(){ n = 0;};

  ~B(){};

  int getB(){ return n;};

  void setB(int t){ n = t;};

 

private:

 int n;

};

 

int main(int argc, char * argv[])

{

  B b;

  b.setA(10); //设置基类的成员变量n

 

  cout<<"A::n "<<b.getA()<<endl;                                   

  cout<<"B::n "<<b.getB()<<endl;                                                                            

  b.setB(9); //设置派生类的成员变量n                                                          

  cout<<"A::n "<<b.getA()<<endl;                                   

  cout<<"B::n "<<b.getB()<<endl;                                                              

  return 0;                                        

}

结果如下：

A::n 10

B::n 0

A::n 10

B::n 9

 

构造函数调用顺序：基类 > 成员类 > 派生类； 

多继承派生类： 基类构造顺序 依照 基类继承顺序调用

类成员：依照 类成员对象 定义顺序 调用成员类构造函数

\#include <iostream>

using namespace std;

 

class Shape {  // 基类 Shape

public:

  Shape() {

​    cout << "Shape" << endl;

  }

  ~Shape() {

​    cout << "~Shape" << endl;

  }

};

 

class PaintCost {  // 基类 PaintCost

public:

  PaintCost() {

​    cout << "PaintCost" << endl;

  }

  ~PaintCost() {

​    cout << "~PaintCost" << endl;

  }

};

 

// 派生类

class Rectangle : public Shape, public PaintCost //基类构造顺序 依照 继承顺序

{

public:

  Rectangle() :b(), a(), Shape(), PaintCost(){

​    cout << "Rectangle" << endl;

  }

  ~Rectangle() {

​    cout << "~Rectangle" << endl;

  }

  PaintCost b;    // 类成员变量构造顺序 依照 变量定义顺序

  Shape a; 

};

 

int main(void)

{

  Rectangle Rect;

  return 0;

}

结果：

Shape

PaintCost

PaintCost

Shape

Rectangle

~Rectangle

~Shape

~PaintCost

~PaintCost

~Shape

 

 

### 一些顺序

1、 对于两个独立的类，构造函数和析构函数的顺序相反

\#include <iostream>

using namespace std;

class A

{

public:

  A() { cout << "Agouzao\n"; }

  ~A() { cout << "Axigou\n"; }

};

 

class B

{

public:

  B() { cout << "Bgouzao\n"; }

  ~B() { cout << "Bxxigo\n"; }

};

 

int main()

{

  A a; // 先定义

  B b; // 后定义

  return 0;

}

Agouzao

Bgouzao

Bxxigo

Axigou

2、 单继承下，对于基类、成员类和派生类的构造函数，也是构造函数和析构函数相反

using namespace std;

\#include <iostream>

class Member

{

public:

  Member() { cout << "Membergouzao\n"; }

  ~Member() { cout << "Memberxigou\n"; }

};

 

class Base

{

public:

  Base() { cout << "Basegouzao\n"; }

  ~Base() { cout << "Basexigou\n"; }

};

 

class Derived : public Base

{

  Member m; // 成员对象

  

public:

  Derived() { cout << "Derivedgouzao\n"; }

  ~Derived() { cout << "Derivedxigou\n"; }

};

 

int main()

{

  Derived d;

  return 0;

}

Basegouzao

Membergouzao

Derivedgouzao

Derivedxigou

Memberxigou

Basexigou

3、 多继承下在2的基础上

**构造顺序**：按继承声明顺序调用基类构造函数
 **析构顺序**：按继承声明逆序调用基类析构函数、

4**成员对象的析构顺序**

**构造顺序**：按成员声明顺序调用构造函数
 **析构顺序**：按成员声明逆序调用析构函数

**5. 为什么析构顺序要与构造顺序相反？**

1. **资源依赖**：派生类可能依赖基类或成员对象的资源，必须先释放派生类自己的资源。
2. **栈式管理**：C++对象生命周期遵循栈的规则（后进先出）。
3. **安全性**：避免悬空指针或资源泄漏（例如派生类析构时若基类已销毁，访问基类成员会导致未定义行为）。

6、程序执行结束前，调用析构函数将数组中各个对象元素释放，释放顺序与创建对象的顺序相反。

 

基类指针指向派生类对象时，如果基类析构函数不是虚函数，只会调用基类的析构函数。

\#include <iostream>

using namespace std;

class A {

public:

  A() { cout << "A"; }

  ~A() { cout << "~A"; }

};

class B : public A {

public:

  B() { cout << "B"; }

  ~B() { cout << "~B"; }

};

int main() {

  A *a = new B();

  delete a;

  return 0;

}

同名覆盖原则

派生类覆盖基类

 

 

### 赋值兼容原则

在公有继承下，派生类或子孙类对象也是一种特殊的基类对象，具有基类对象的属性和公有函数。因此，在需要基类对象的场合，派生类对象或子孙类对象也可以满足需要。这称为赋值兼容原则。

、对于对象指针类型。指针变量类型用于存放对象的地址，指向对象。

指针类型变量可以指向本类对象，还允许基类指针变量指向派生类对象或子孙类对象，但不可以指向祖先类对象；

基类指针变量作为形参时，实参可以是指向本类对象那个的指针、指向派生类对象或子孙类对象的指针，不可以是在祖先类对象的指针。

函数对象返回对象指针类型时，函数可以返回本类对象的指针，派生类对象或子孙类对象的指针，但不可以返回祖先类对象的指针。

赋值时，可以给本类对象指针类型的变量赋值本类对象指针、派生类对象指针或子孙类对象指针，但不可以将祖先类对象的指针赋值给子孙类对象指针类型的变量。

首先考虑率对象指针类型。

赋值兼容原则指出：

1、对于对象指针类型。指针变量类型用于存放对象的地址，指向对象。

指针类型变量可以指向本类对象，还允许基类指针变量指向派生类对象或子孙类对象，但不可以指向祖先类对象（即将祖先类对象的指针赋值给基类指针）；

“指向“的意思即可以将此类对象的指针赋值给此类指针变量

即：

基类指针变量作为形参时，实参可以是指向本类对象的指针、指向派生类对象或子孙类对象的指针，不可以是在祖先类对象的指针。

函数对象返回本类对象指针类型时，函数可以返回本类对象的指针，派生类对象或子孙类对象的指针，但不可以返回祖先类对象的指针。

赋值时，可以给本类对象指针类型的变量赋值本类对象指针、派生类对象指针或子孙类对象指针，但不可以将祖先类对象的指针赋值给子孙类对象指针类型的变量。（？这句话有问题）

基类指针可以指向派生类对象（向上转型，“上“指的是派生类对象指针可以向上转型到基类指针，安全，因为派生类必然包含基类部分）

派生类指针不能指向基类对象（向下转型，“下“指的是基类指针不能向下转型到派生类指针，不安全，因为基类可能不包含派生类的扩展部分）

![img](data:image/png;base64,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)

class Base { /* ... */ };

class Derived : public Base { /* ... */ };

Base *pBase;   // 基类指针

Derived objDerived; 

pBase = &objDerived; // ✅ 合法：基类指针指向派生类对象

Derived *pDerived;

Base objBase;

pDerived = &objBase; // ❌ 错误：派生类指针不能指向基类对象

pDerived = static_cast<Derived*>(&objBase); // ⚠️ 危险！仅当确定 objBase 实际是 Derived 时才安全

pDerived = dynamic_cast<Derived*>(&objBase); // ✅ 更安全（但 objBase 必须是多态类，即含虚函数）

\#include <iostream>

using namespace std;

 

class Animal {

public:

  virtual void speak() { cout << "Animal sound\n"; }

};

 

class Dog : public Animal {

public:

  void speak() override { cout << "Woof!\n"; }

  void fetch() { cout << "Fetching stick\n"; }

};

 

int main() {

  Animal *pAnimal; // 基类指针

  Dog dog;     // 派生类对象

 

  pAnimal = &dog;  // ✅ 合法：基类指针指向派生类对象

  pAnimal->speak(); // 输出 "Woof!"（多态调用）

 

  // pAnimal->fetch(); ❌ 错误：Animal 类没有 fetch() 方法

}

基类指针接收派生类指针，实参是派生类指针

void makeSound(Animal *pAnimal) {

  pAnimal->speak();

}

 

int main() {

  Dog dog;

  makeSound(&dog); // ✅ 合法：传递派生类指针给基类指针参数

}

函数返回基类指针（实际上返回派生类指针）

Animal* createAnimal(bool isDog) {

  if (isDog) {

​    return new Dog(); // ✅ 合法：返回派生类指针

  }

  return new Animal();

}

 

int main() {

  Animal *pAnimal = createAnimal(true);

  pAnimal->speak(); // 输出 "Woof!"

  delete pAnimal;

}

对象切片问题。call()参数按值传递，生成的是A的副本，虚函数机制失效。

 

C++可以将对象赋值给同类对象变量，与前面讨论的对象指针、对象引用不同。

C++允许将对象赋值给基类变量，但实际复制到是基类的部分子对象，切片现象。

 

## 多态

**多态**按字面的意思就是多种形态。

当类之间存在层次结构，并且类之间是通过继承关联时，就会用到多态。

在 C++ 中，多态（Polymorphism）是面向对象编程的重要特性之一。

C++ 多态允许使用基类指针或引用来调用子类的重写方法，从而使得同一接口可以表现不同的行为。

多态使得代码更加灵活和通用，程序可以通过基类指针或引用来操作不同类型的对象，而不需要显式区分对象类型。这样可以使代码更具扩展性，在增加新的形状类时不需要修改主程序。

### 多态的几个关键点：

**虚函数（Virtual Functions）**：

- 在基类中声明一个函数为虚函数，使用关键字virtual。
- 派生类可以重写（override）这个虚函数。
- 调用虚函数时，会根据对象的实际类型来决定调用哪个版本的函数。

**动态绑定（Dynamic Binding）**：

- 也称为晚期绑定（Late Binding），在运行时确定函数调用的具体实现。
- 需要使用指向基类的指针或引用来调用虚函数，编译器在运行时根据对象的实际类型来决定调用哪个函数。

**纯虚函数（Pure Virtual Functions）**：

- 一个包含纯虚函数的类被称为抽象类（Abstract Class），它不能被直接实例化。
- 纯虚函数没有函数体，声明时使用= 0。
- 它强制派生类提供具体的实现。

**多态的实现机制**：

- 虚函数表（V-Table）：C++运行时使用虚函数表来实现多态。每个包含虚函数的类都有一个虚函数表，表中存储了指向类中所有虚函数的指针。
- 虚函数指针（V-Ptr）：对象中包含一个指向该类虚函数表的指针。

**使用多态的优势**：

- **代码复用**：通过基类指针或引用，可以操作不同类型的派生类对象，实现代码的复用。
- **扩展性**：新增派生类时，不需要修改依赖于基类的代码，只需要确保新类正确重写了虚函数。
- **解耦**：多态允许程序设计更加模块化，降低类之间的耦合度。

**注意事项**：

- 只有通过基类的指针或引用调用虚函数时，才会发生多态。
- 如果直接使用派生类的对象调用函数，那么调用的是派生类中的版本，而不是基类中的版本。
- 多态性需要运行时类型信息（RTTI），这可能会增加程序的开销。

\#include <iostream>

using namespace std;

 

// 基类 Animal

class Animal {

public:

  // 虚函数 sound，为不同的动物发声提供接口

  virtual void sound() const {

​    cout << "Animal makes a sound" << endl;

  }

  

  // 虚析构函数确保子类对象被正确析构

  virtual ~Animal() { 

​    cout << "Animal destroyed" << endl; 

  }

};

 

// 派生类 Dog，继承自 Animal

class Dog : public Animal {

public:

  // 重写 sound 方法

  void sound() const override {

​    cout << "Dog barks" << endl;

  }

  

  ~Dog() {

​    cout << "Dog destroyed" << endl;

  }

};

 

// 派生类 Cat，继承自 Animal

class Cat : public Animal {

public:

  // 重写 sound 方法

  void sound() const override {

​    cout << "Cat meows" << endl;

  }

  

  ~Cat() {

​    cout << "Cat destroyed" << endl;

  }

};

 

// 测试多态

int main() {

  Animal* animalPtr; // 基类指针

 

  // 创建 Dog 对象，并指向 Animal 指针

  animalPtr = new Dog();

  animalPtr->sound(); // 调用 Dog 的 sound 方法

  delete animalPtr;  // 释放内存，调用 Dog 和 Animal 的析构函数

 

  // 创建 Cat 对象，并指向 Animal 指针

  animalPtr = new Cat();

  animalPtr->sound(); // 调用 Cat 的 sound 方法

  delete animalPtr;  // 释放内存，调用 Cat 和 Animal 的析构函数

 

  return 0;

}

**主函数 main()**：

- 创建一个基类指针 animalPtr。
- 使用 new Dog() 创建 Dog 对象，将其地址赋给 animalPtr。此时，调用 animalPtr->sound() 会输出"Dog barks"，因为 animalPtr 实际指向的是 Dog 对象。
- 释放 Dog 对象时，先调用 Dog 的析构函数，再调用 Animal 的析构函数。
- 使用 new Cat() 创建 Cat 对象并赋给 animalPtr，再调用 animalPtr->sound()，输出"Cat meows"，显示多态行为。

- **虚函数**：通过在基类中使用 virtual 关键字声明虚函数，派生类可以重写这个函数，从而使得在运行时根据对象类型调用正确的函数。
- **动态绑定**：C++ 的多态通过动态绑定实现。在运行时，基类指针 animalPtr 会根据它实际指向的对象类型（Dog 或 Cat）调用对应的 sound() 方法。
- **虚析构函数**：在具有多态行为的基类中，析构函数应该声明为 virtual，以确保在删除派生类对象时调用派生类的析构函数，防止资源泄漏。

### 虚函数

**虚函数**是在基类中使用关键字 **virtual** 声明的函数。

**虚函数**允许子类重写它，从而在运行时通过基类指针或引用调用子类的重写版本，实现动态绑定。

我们想要的是在程序中任意点可以根据所调用的对象类型来选择调用的函数，这种操作被称为**动态链接**，或**后期绑定。**

**特点：**

- **在基类中可以有实现**。通常虚函数在基类中提供默认实现，但子类可以选择重写。
- **动态绑定**：在运行时根据对象的实际类型调用相应的函数版本。
- **可选重写**：派生类可以选择性地重写虚函数，但不是必须。

虚函数不能是静态成员函数，因为静态成员函数属于类而非对象，无法实现运行时多态。

 

 

核心概念解析

"继承下来的不管加不加都是虚的"

 

当基类声明了一个虚函数（virtual），所有派生类中同名、同签名的函数自动成为虚函数，无论是否显式添加virtual关键字。

 

这是C++的默认行为，目的是保持多态性的一致性。

 

cpp

class Base {

public:

  virtual void show() { cout << "Base\n"; } // 显式virtual

};

 

class Derived : public Base {

public:

  void show() { cout << "Derived\n"; } // 自动成为虚函数（即使不加virtual）

};

"不做成虚的就是基类虚函数"

 

如果派生类中定义的函数与基类虚函数签名不同（如参数类型不同），则不会覆盖基类虚函数，而是成为一个独立的新函数。

 

此时基类的虚函数仍然存在，但派生类的新函数不会参与多态。

 

cpp

class Base {

public:

  virtual void show(int x) { cout << "Base " << x << "\n"; }

};

 

class Derived : public Base {

public:

  void show() { cout << "Derived\n"; } // ❌ 不是虚函数覆盖，而是新函数

};

 

// 使用时：

Base* b = new Derived();

b->show(1); // 调用Base::show(int)，而非Derived::show()

关键规则总结

情况    是否覆盖虚函数  是否需要override关键字（C++11推荐）

派生类函数与基类虚函数完全同签名   ✅ 是  建议加override

派生类函数与基类虚函数签名不同  ❌ 否  编译错误（若误用override）

基类函数非虚，派生类同名函数   ❌ 不是虚函数  不应加override

为什么需要override关键字？（C++11引入）

为了避免意外隐藏（而非覆盖）基类虚函数，强烈建议在派生类中显式标记override：

 

cpp

class Derived : public Base {

public:

  void show(int x) override { cout << "Derived " << x << "\n"; } // ✅ 明确覆盖

  void show() const override; // ❌ 编译错误：签名不匹配基类虚函数

};

多态行为的必要条件

基类函数必须声明为virtual。

 

派生类函数必须签名完全一致（包括const和引用限定符）。

 

通过基类指针/引用调用才能触发多态。

 

cpp

Base* b = new Derived();

b->show(); // 多态调用Derived::show()（如果覆盖正确）

常见误区纠正

误区："派生类不加virtual就不是虚函数"

事实：只要基类有virtual，派生类同名同签名函数自动继承虚属性。

 

误区："函数名相同就能覆盖"

事实：必须严格匹配签名（参数类型、const等）。

 

最佳实践

基类虚函数显式用virtual。

 

派生类覆盖函数显式用override（C++11起）。

 

使用final禁止进一步覆盖（如果需要）。

 

cpp

class Base {

public:

  virtual ~Base() = default;     // 虚析构函数（多态基类必须）

  virtual void foo(int) const;    // 虚函数

};

 

class Derived : public Base {

public:

  void foo(int) const override;    // 明确覆盖

  void bar() final;          // 禁止派生类覆盖

};

### 纯虚函数

您可能想要在基类中定义虚函数，以便在派生类中重新定义该函数更好地适用于对象，但是您在基类中又不能对虚函数给出有意义的实现，这个时候就会用到纯虚函数。

纯虚函数是没有实现的虚函数，在基类中用 **= 0** 来声明。

纯虚函数表示基类定义了一个接口，但具体实现由派生类负责。

纯虚函数使得基类变为抽象类（abstract class），无法实例化。

**特点：**

- **必须在基类中声明为 = 0**，表示没有实现，子类必须重写。
- **抽象类**：包含纯虚函数的类不能直接实例化，必须通过派生类实现所有纯虚函数才能创建对象。
- **接口定义**：纯虚函数通常用于定义接口，让派生类实现具体行为。

**虚函数与纯虚函数的对比**

| **特性** | **虚函数（Virtual Function）**  | **纯虚函数（Pure Virtual Function）** |
| -------- | ------------------------------- | ------------------------------------- |
| 定义     | 基类中使用 virtual 声明，有实现 | 基类中使用 = 0 声明，无实现           |
| 子类重写 | 子类可以选择重写                | 子类必须实现                          |
| 抽象性   | 可以实例化类                    | 使类变为抽象类，无法实例化            |
| 用途     | 提供默认行为，允许子类重写      | 定义接口，强制子类实现具体行为        |

1、纯虚函数声明如下： virtual void funtion1()=0; 纯虚函数一定没有定义，纯虚函数用来规范派生类的行为，即接口。包含纯虚函数的类是抽象类，抽象类不能定义实例，但可以声明指向实现该抽象类的具体类的指针或引用。

2、虚函数声明如下：virtual ReturnType FunctionName(Parameter) 虚函数必须实现，如果不实现，编译器将报错、

3、对于虚函数来说，父类和子类都有各自的版本。由多态方式调用的时候动态绑定。

4、实现了纯虚函数的子类，该纯虚函数在子类中就变成了虚函数，子类的子类即孙子类可以覆盖该虚函数，由多态方式调用的时候动态绑定。

5、虚函数是C++中用于实现多态(polymorphism)的机制。核心理念就是通过基类访问派生类定义的函数。

6、在有动态分配堆上内存的时候，析构函数必须是虚函数，但没有必要是纯虚的。

7、友元不是成员函数，只有成员函数才可以是虚拟的，因此友元不能是虚拟函数。但可以通过让友元函数调用虚拟成员函数来解决友元的虚拟问题。

8、析构函数应当是虚函数，将调用相应对象类型的析构函数，因此，如果指针指向的是子类对象，将调用子类的析构函数，然后自动调用基类的析构函数。

1、必须存在继承关系；

2、继承关系必须有同名虚函数（**其中虚函数是在基类中使用关键字Virtual声明的函数，在派生类中重新定义基类中定义的虚函数时，会告诉编译器不要静态链接到该函数**）；

3、存在基类类型的指针或者引用，通过该指针或引用调用虚函数；

**动态联编的实现机制 VTABLE**

编译器对每个包含虚函数的类创建一个虚函数表VTABLE，表中每一项指向一个虚函数的地址，即VTABLE表可以看成一个函数指针的数组，每个虚函数的入口地址就是这个数组的一个元素。

每个含有虚函数的类都有各自的一张虚函数表VTABLE。每个派生类的VTABLE继承了它各个基类的VTABLE，如果基类VTABLE中包含某一项（虚函数的入口地址），则其派生类的VTABLE中也将包含同样的一项，但是两项的值可能不同。如果派生类中重载了该项对应的虚函数，则派生类VTABLE的该项指向重载后的虚函数，如果派生类中没有对该项对应的虚函数进行重新定义，则使用基类的这个虚函数地址。

在创建含有虚函数的类的对象的时候，编译器会在每个对象的内存布局中增加一个vptr指针项，该指针指向本类的VTABLE。在通过指向基类对象的指针（设为bp）调用一个虚函数时，编译器生成的代码是先获取所指对象的vtb1指针，然后调用vtb1所指向类的VTABLE中的对应项（具体虚函数的入口地址）。

当基类中**没有定义虚函数**时，其长度=数据成员长度；派生类长度=自身数据成员长度+基类继承的数据成员长度；

当基类中**定义虚函数后**，其长度=数据成员长度+虚函数表的地址长度；派生类长度=自身数据成员长度+基类继承的数据成员长度+虚函数表的地址长度。

包含一个虚函数和几个虚函数的类的长度增量为0。含有虚函数的类只是增加了一个指针用于存储虚函数表的首地址。

派生类与基类同名的虚函数在VTABLE中有相同的索引号（或序号）。

A 类继承 B 类，A 类重写了 B 类的虚函数 B2，而 B 类的 B1 中调用了 B2，则 A 类使用 B1 时，运行时 B1 中的 B2 将执行 A 类中重写的虚函数B2。

\#include <iostream>

using namespace std;

class B

{

public:  

void B1(void)

{

 B2();

}

 

virtual void B2(void)

{

 cout << "Hello, B2" << endl;

}

  

};

 

class A:public B

{

public:

virtual void B2(void)

{

 cout << "Hello, A" << endl;

}

 

};

定义一个函数为虚函数，不代表函数为不被实现的函数。

定义他为虚函数是为了允许用基类的指针来调用子类的这个函数。

定义一个函数为纯虚函数，才代表函数没有被实现。

定义纯虚函数是为了实现一个接口，起到一个规范的作用，规范继承这个类的程序员必须实现这个函数。

 

#### Final关键字

父类的虚函数或纯虚函数在子类中依然是虚函数。有时我们并不希望父类的某个函数在子类中被重写，在 C++11 及以后可以用关键字 final 来避免该函数再次被重写。

如果不希望一个类被继承，也可以使用 final 关键字。

格式如下：

class Class_name final

{

  ...

};

则该类将不能被继承。

 

## 模板

模板是泛型编程的基础，泛型编程即以一种独立于任何特定类型的方式编写代码。

 

模板是创建泛型类或函数的蓝图或公式。库容器，比如迭代器和算法，都是泛型编程的例子，它们都使用了模板的概念。

 

每个容器都有一个单一的定义，比如 向量，我们可以定义许多不同类型的向量，比如 vector <int> 或 vector <string>。

 

您可以使用模板来定义函数和类，接下来让我们一起来看看如何使用。

 

### 函数模板

模板函数定义的一般形式如下所示：

 

template <typename type> ret-type func-name(parameter list)

{

  // 函数的主体

}

在这里，type 是函数所使用的数据类型的占位符名称。这个名称可以在函数定义中使用。

 

下述两种在表达式中使用函数模板的方式都可以让编译器生成模板含函数并调用该模板函数

 

函数模板名（实参表）

函数模板名（类型1类型2）（实参表）

 

#### 函数模板可以重载

只要它们的形参表不同即可。例如，下面两个模板可以同时存在：

template<class T1, class T2>

void print(T1 arg1, T2 arg2)

{

 cout<<arg1<<" "<<arg2<<endl; 

}

template<class T>

void print(T arg1, T arg2)

{

 cout<< arg1<< " "<< arg2<< endl;

}

 

#### 规则

即使函数模板的实现中没有用到模板参数，只要它的声明是 template <typename T>，它就仍然是一个模板，而不是普通函数。

示例：

// 这是一个函数模板（即使没有用到 T）

template <typename T>

void foo() {

  std::cout << "This is a function template.\n";

}

调用 foo() 时，必须提供模板参数（如 foo<int>()），否则会编译错误（除非模板参数可推导）。

 

不会自动退化为普通函数，因为 C++ 不允许隐式省略模板参数。

#### 函数模板特化和部分特化机制

template <> 

void swap<int>(int& a, int& b) {

  *//* *针对 int 类型的 swap 实现*

}

- 这是一个 **全特化（Explicit Specialization）** 的 **swap** 函数模板，仅适用于 **int** 类型。
- 当调用 **swap<int>(x, y)** 时，编译器会优先使用这个特化版本，而不是通用的 **swap** 模板。



**3. 为什么需要模板特化？**

- **性能优化**：针对某些类型（如 **int**），可以手动实现更高效的版本（比如直接用 **std::swap** 的默认实现）。
- **特殊处理**：某些类型可能需要特殊的交换逻辑（例如含有资源句柄的类）。
- **避免通用模板的缺陷**：通用模板可能不适用于某些特定类型。



**4. 对比通用模板**

假设有一个通用的 **swap** 模板：

cpp

复制

下载

template <typename T>

void swap(T& a, T& b) {

  T tmp = a;

  a = b;

  b = tmp;

}

现代 C++ 推荐使用 **函数重载** 而非模板特化：

*// 通用模板*

template <typename T>

const T& Max(const T& a, const T& b) { return a > b ? a : b; }

 

*// 重载版本：针对 const char**

const char* Max(const char* a, const char* b) {

  return strcmp(a, b) > 0 ? a : b;

}

 

### 类模板

正如我们定义函数模板一样，我们也可以定义类模板。泛型类声明的一般形式如下所示：

 

template <class type> class class-name {

.

.

.

}

在这里，type 是占位符类型名称，可以在类被实例化的时候进行指定。您可以使用一个逗号分隔的列表来定义多个泛型数据类型。

 

下面的实例定义了类 Stack<>，并实现了泛型方法来对元素进行入栈出栈操作：

\#include <iostream>

\#include <vector>

\#include <cstdlib>

\#include <string>

\#include <stdexcept>

 

using namespace std;

 

template <class T>

class Stack { 

 private: 

  vector<T> elems;   // 元素

 

 public: 

  void push(T const&); // 入栈

  void pop();        // 出栈

  T top() const;      // 返回栈顶元素

  bool empty() const{    // 如果为空则返回真。

​    return elems.empty(); 

  }

}; 

 

template <class T>

void Stack<T>::push (T const& elem) 

{ 

  // 追加传入元素的副本

  elems.push_back(elem);  

} 

 

template <class T>

void Stack<T>::pop () 

{ 

  if (elems.empty()) { 

​    throw out_of_range("Stack<>::pop(): empty stack"); 

  }

  // 删除最后一个元素

  elems.pop_back();     

} 

 

template <class T>

T Stack<T>::top () const 

{ 

  if (elems.empty()) { 

​    throw out_of_range("Stack<>::top(): empty stack"); 

  }

  // 返回最后一个元素的副本 

  return elems.back();   

} 

 

int main() 

{ 

  try { 

​    Stack<int>     intStack; // int 类型的栈 

​    Stack<string> stringStack;  // string 类型的栈 

 

​    // 操作 int 类型的栈 

​    intStack.push(7); 

​    cout << intStack.top() <<endl; 

 

​    // 操作 string 类型的栈 

​    stringStack.push("hello"); 

​    cout << stringStack.top() << std::endl; 

​    stringStack.pop(); 

​    stringStack.pop(); 

  }

  catch (exception const& ex) { 

​    cerr << "Exception: " << ex.what() <<endl; 

​    return -1;

  }

}

 

#### Typename的作用

在模板定义语法中关键字 class 与 typename 的作用完全一样。

typename 难道仅仅在模板定义中起作用吗？其实不是这样，typename 另外一个作用为：使用嵌套依赖类型(nested depended name)，如下所示：

class MyArray 

{ 

  public：

  typedef int LengthType;

.....

}

 

template<class T>

void MyMethod( T myarr ) 

{ 

  typedef typename T::LengthType LengthType; 

  LengthType length = myarr.GetLength; 

}

这个时候 typename 的作用就是告诉 c++ 编译器，typename 后面的字符串为一个类型名称，而不是成员函数或者成员变量，这个时候如果前面没有 typename，编译器没有任何办法知道 T::LengthType 是一个类型还是一个成员名称(静态数据成员或者静态函数)。

 

在类模板外定义成员函数时，模板参数列表必须与类模板声明时的参数列表**完全一致**，不能增加、减少或改变顺序。也就是说，你在类模板外定义成员函数时使用的模板参数必须与类模板声明时的参数**一一对应**。

template <typename T> 

class Stack {

public:

  void push(const T& value);

  T pop();

};

✅ 正确方式：

在类外定义成员函数时，模板参数必须与类模板声明一致（这里是 template <typename T>）：

template <typename T> 

void Stack<T>::push(const T& value) {

  // 实现代码

}

template <typename T> 

T Stack<T>::pop() {

  // 实现代码

  return T();

}

*// 错误！模板参数数量不匹配（多了一个 U）*

template <typename T, typename U> 

void Stack<T>::push(const T& value) {

  *// ...*

}

 

*// 错误！模板参数名称不匹配（用了 U 而不是 T）*

template <typename U> 

U Stack<U>::pop() {

  *// ...*

}

**为什么必须一致？**

- **模板实例化规则**：类模板的成员函数定义必须与类模板的声明匹配，否则编译器无法正确关联成员函数与类模板。
- **类型推导依赖**：成员函数的模板参数必须与类模板的参数一致，否则会导致类型推导错误。

 类模板的声明

template <typename T, typename U> 

class MyClass { ... };

作用：声明一个名为 MyClass 的类模板，它有两个模板参数 T 和 U。

 

包含内容：成员函数的声明（如 void foo(T x);），但无实现。

 

 类模板参数列表

template <typename T, typename U>

位置：在类模板声明和成员函数定义的开头。

 

作用：声明模板的泛型参数（T 和 U 是类模板参数）。

 

 

成员函数定义

template <typename T, typename U>

void MyClass<T, U>::foo(T x) { ... }

作用：提供成员函数的具体实现。

 

必须匹配：

 

模板参数列表（template <typename T, typename U>）必须与类模板声明一致。

 

类名后的模板参数（MyClass<T, U>）必须包含所有类模板参数（即使未使用）。

#### 特殊情况：成员函数模板

如果你想在成员函数中使用**额外的模板参数**（不同于类模板的参数），可以定义**成员函数模板**，但这与类模板的成员函数定义是不同的概念：

template <typename T> 

class Stack {

public:

  template <typename U>

  void foo(const U& value); *//* *成员函数模板*

};

 

*// 定义成员函数模板（注意：这里有两个模板参数）*

template <typename T> 

template <typename U>

void Stack<T>::foo(const U& value) {

  *//* *实现代码*

}

 

#### 1. 声明（Declaration）

- **作用**：告诉编译器某个实体（变量、函数、类等）的存在及其基本属性（如类型、名称），但不分配内存或提供具体实现。
- **特点**：
  - 可以多次声明（不冲突）。
  - 不生成实际代码或占用内存。
- **常见形式**：
  - 函数声明：**void foo(int x);**
  - 类声明：**class MyClass;**
  - 类模板声明：**template <typename T> class MyVector;**

**示例：类模板的声明**

*// 类模板的声明（包含成员函数声明）*

template <typename T>

class Container {

public:

  void add(const T& item); *//* *成员函数声明*

  T get(int index) const; *//* *成员函数声明*

private:

  T* data;

};

- 这里只声明了**Container**类和它的成员函数，但没有实现（定义）它们。

#### 2.类模板的参数（Template Parameters）

类模板的参数是指 **模板声明中定义的占位符类型或值**（如 **T**、**int N** 等），它们在实例化时被替换为具体类型或值。
 参数分为两种：

1. **类型参数**（用 **typename** 或 **class** 声明）：

template <typename T> *// T* *是类型参数*

1. **非类型参数**（用具体类型声明，如 **int**）：

template <typename T, int N> *// N* *是非类型参数*

**关键点：**

- 模板参数是 **声明的一部分**，用于定义模板的泛型行为。
- 实例化时，参数会被替换为具体类型（如 **MyClass<int>** 中的 **T     = int**）

 



#### 3. 定义（Definition）

- **作用**：提供实体的完整实现或内存分配，编译器会根据定义生成代码。
- **特点**：
  - 只能定义一次（违反会导致链接错误）。
  - 对变量：分配内存。
  - 对函数/类：提供具体实现。
- **常见形式**：
  - 函数定义：**void foo(int x) { /\* 实现 \*/ }**
  - 类定义：**class MyClass { /\* 成员和数据 \*/ };**
  - 类模板成员函数定义：**template <typename T> void Container<T>::add(const      T& item) { /\* 实现 \*/ }**

**示例：类模板成员函数的定义**

*// 类模板成员函数的定义（必须匹配声明）*

template <typename T>

void Container<T>::add(const T& item) {

  *//* *具体实现（例如将 item 存入 data 数组）*

}

 

template <typename T>

T Container<T>::get(int index) const {

  *//* *具体实现（例如返回 data[index]）*

}

- 这些定义必须与类模板的声明严格匹配（包括模板参数**T**和类名后的**Container<T>**）。

| **特性**               | **声明（Declaration）**                   | **定义（Definition）**                               |
| ---------------------- | ----------------------------------------- | ---------------------------------------------------- |
| **目的**               | 告诉编译器“某个东西存在”                  | 告诉编译器“这个东西的具体实现”                       |
| **内存/代码生成**      | 不分配内存或生成代码                      | 分配内存或生成可执行代码                             |
| **重复性**             | 可多次声明（如头文件中的函数声明）        | 只能定义一次（否则链接错误）                         |
| **类模板中的成员函数** | 在类模板内部声明（如 **void foo(T x);**） | 在类模板外部定义（需完整模板语法）                   |
| **示例**               | **template  <typename T> class MyClass;** | **template  <typename T> void MyClass<T>::foo() {}** |

 

 

**. 用 T 定义数据成员的类型**

std::vector<T> data; *// data* *是一个 vector，元素类型由 T 决定*

- 当 **Container<int>** 实例化时，**data** 的类型是 **std::vector<int>**。
- 当 **Container<std::string>** 实例化时，**data** 的类型是 **std::vector<std::string>**。

**2. 用 T 定义成员函数的参数和返回值**

void add(const T& item); *//* *参数类型是 T 的引用*

T get(size_t index) const; *//* *返回值类型是 T*

- **add** 接受一个 **T** 类型的参数（如 **int** 或 **std::string**）。
- **get** 返回 **T** 类型的值。

**3. 用 T 定义类内部的类型成员（嵌套类型）**

typedef T ValueType; *//* *定义 ValueType 为 T 的别名*

using Iterator = typename std::vector<T>::iterator; *//* *定义 Iterator 类型*

- **ValueType** 是 **T** 的别名，外部可通过 **Container<int>::ValueType** 访问。
- **Iterator** 是 **std::vector<T>::iterator** 的别名，用于迭代 **data** 成员。

 

此时由类模板产生

类模板名《类型》

类模板名《类型1，类型2》

 

#### 模板元编程

## 异常处理和智能指针

异常处理的基本思想

由三个部分组成：检查try、抛出throw、捕获异常catch throw里的内容

- **throw:** 当问题出现时，程序会抛出一个异常。这是通过使用 **throw** 关键字来完成的。
- **catch:** 在您想要处理问题的地方，通过异常处理程序捕获异常。**catch** 关键字用于捕获异常。
- **try:** **try** 块中的代码标识将被激活的特定异常。它后面通常跟着一个或多个 catch 块。

如果有一个块抛出一个异常，捕获异常的方法会使用 **try** 和 **catch** 关键字。try 块中放置可能抛出异常的代码，try 块中的代码被称为保护代码。使用 try/catch 语句的语法如下所示：

try { // 保护代码 }catch( ExceptionName e1 ) { // catch 块 }catch( ExceptionName e2 ) { // catch 块 }catch( ExceptionName eN ) { // catch 块 }

**C++ 标准的异常**

C++ 提供了一系列标准的异常，定义在 **<exception>** 中，我们可以在程序中使用这些标准的异常。它们是以父子类层次结构组织起来的，如下所示：

![img](data:image/png;base64,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)

 

| **异常**               | **描述**                                                     |
| ---------------------- | ------------------------------------------------------------ |
| **std::exception**     | 该异常是所有标准 C++ 异常的父类。                            |
| std::bad_alloc         | 该异常可以通过 **new** 抛出。                                |
| std::bad_cast          | 该异常可以通过 **dynamic_cast** 抛出。                       |
| std::bad_typeid        | 该异常可以通过 **typeid** 抛出。                             |
| std::bad_exception     | 这在处理 C++ 程序中无法预期的异常时非常有用。                |
| **std::logic_error**   | 理论上可以通过读取代码来检测到的异常。                       |
| std::domain_error      | 当使用了一个无效的数学域时，会抛出该异常。                   |
| std::invalid_argument  | 当使用了无效的参数时，会抛出该异常。                         |
| std::length_error      | 当创建了太长的 std::string 时，会抛出该异常。                |
| std::out_of_range      | 该异常可以通过方法抛出，例如 std::vector 和  std::bitset<>::operator[]()。 |
| **std::runtime_error** | 理论上不可以通过读取代码来检测到的异常。                     |
| std::overflow_error    | 当发生数学上溢时，会抛出该异常。                             |
| std::range_error       | 当尝试存储超出范围的值时，会抛出该异常。                     |
| std::underflow_error   | 当发生数学下溢时，会抛出该异常。                             |

**定义新的异常**

您可以通过继承和重载 **exception** 类来定义新的异常。下面的实例演示了如何使用 std::exception 类来实现自己的异常：

\#include <iostream>

\#include <exception>

using namespace std;

 

struct MyException : public exception

{

 const char * what () const throw ()

 {

  return "C++ Exception";

 }

};

 

int main()

{

 try

 {

  throw MyException();

 }

 catch(MyException& e)

 {

  std::cout << "MyException caught" << std::endl;

  std::cout << e.what() << std::endl;

 }

 catch(std::exception& e)

 {

  //其他的错误

 }

}

### std::exception

std::exception 是 C++ 标准库中定义的基类，用于所有标准异常类的基础。它定义了一些虚函数，如 what()，用于返回异常信息的 C 风格字符串。

class exception {

public:

  virtual const char* what() const noexcept;

};

 

**what()** 是异常类提供的一个公共方法，它已被所有子异常类重载。这将返回异常产生的原因。

const throw() 不是函数，这个东西叫异常规格说明，表示 what 函数可以抛出异常的类型，类型说明放到 () 里，这里面没有类型，就是声明这个函数不抛出异常，通常函数不写后面的 throw() 就表示函数可以抛出任何类型的异常。

1、异常规格说明的目的是为了让函数使用者知道该函数可能抛出的异常有哪些。 可以在函数的声明中列出这个函数可能抛掷的所有异常类型。例如：

void fun() throw(A，B，C，D);

2、若无异常接口声明，则此函数可以抛掷任何类型的异常。

3、不抛掷任何类型异常的函数声明如下：

每个标准库异常类都定义了名为 what 的成员函数。这些函数没有参数，返回值是 C 风格字符串（即 const char *）其中，runtime_error 的 what 成员函数返回的是初始化一个具体对象所用的 string 对象的副本。

在 C++11 中，声明一个函数不可以抛出任何异常使用关键字 noexcept。

void mightThrow(); // could throw any exceptions.

void doesNotThrow() noexcept; // does not throw any exceptions.

下面两个函数声明的异常规格在语义上是相同的，都表示函数不抛出任何异常。

void old_stytle() throw();

void new_style() noexcept;

 

const char * what () const throw ()

{

//函数体

}

做几点说明，从左到右看：

- 1. **const char \*** 表示返回值类型
- 2. **what** 是函数名称
- 3. **()** 是参数列表
- 4. **const** 表示该成员函数不能修改成员变量
- 5. **throw()** 是异常规格说明符。括号内写该函数可抛出的异常类型

 

### 结构体的补充

typedef struct [StructName] {

  *//* *成员...*

} AliasName;

typedef struct Student {

  // 成员

} Student; // 这里的 "Student" 是别名

或者

typedef struct {

//成员

} Student;

Student a; // 正确：通过别名声明变量；

否则

typedef struct Student {

  // 结构体成员=

}; // 这里缺少了 typedef 的别名！

struct Student a; // 正确，但未利用 typedef

传统写法：

struct Student {

};

struct Student a; *//* *必须带 "struct"*

如果**不加 typedef**，直接在 **struct** 末尾写名字，那么这个名字是**变量名**（不是类型名）。

struct [StructName] {

  *//* *成员...*

} VariableName;

struct {

  int id;

  char name[20];

} student1; *//* *直接定义了一个变量 "student1"*

struct Student {

  int id;

  char name[20];

} student2; *//* *定义结构体标签 "Student"，并声明变量 "student2"*

 

最后

错误的：

typedef struct {

  int id;

  char name[20];

} Student, student1, student2; *//* *同时定义类型名 Student 和变量 student1、student2*

他们都是结构体的别名。

 

catch 块可以捕获所有异常吗？

可以。使用 catch (...) 可以捕获所有类型的异常（类似于其他语言的 catch (Exception e)）。

示例：

try {

  throw 42; // 抛出一个 int 异常

} catch (...) {

  std::cout << "捕获到未知异常";

}

注意事项：

 

catch (...) 无法直接获取异常对象，需结合 std::current_exception() 或其他机制（如重新抛出）。

 

应优先捕获具体异常类型（如 catch (const std::exception& e)），避免掩盖潜在问题。

 

### Memory

<memory> 是 C++ 标准库中的一个头文件，它包含了用于动态内存管理的模板和函数。

在 C++ 中，内存管理是一个重要的概念。动态内存管理允许程序在运行时分配和释放内存，这在处理不确定大小的数据结构时非常有用。然而，不正确的内存管理可能导致内存泄漏、野指针等问题。

<memory> 头文件提供了智能指针等工具，帮助开发者更安全地管理动态内存。

**智能指针**

智能指针是 <memory> 头文件中的核心内容。它们是 C++11 引入的特性，用于自动管理动态分配的内存。智能指针的主要类型有：

- std::unique_ptr：独占所有权的智能指针，同一时间只能有一个 unique_ptr 指向特定内存。
- std::shared_ptr：共享所有权的智能指针，多个 shared_ptr 可以指向同一内存，内存在最后一个 shared_ptr 被销毁时释放。
- std::weak_ptr：弱引用智能指针，用于与 shared_ptr 配合使用，避免循环引用导致的内存泄漏。

\#include <iostream>

\#include <memory>

 

class MyClass {

public:

  void doSomething() {

​    std::cout << "Doing something" << std::endl;

  }

};

 

int main() {

  std::unique_ptr<MyClass> myPtr(new MyClass());

  myPtr->doSomething(); // 使用智能指针调用成员函数

 

  // 当 main 函数结束时，myPtr 被销毁，自动释放 MyClass 对象的内存

  return 0;

}

\#include <iostream>

\#include <memory>

 

class MyClass {

public:

  void doSomething() {

​    std::cout << "Doing something" << std::endl;

  }

};

 

int main() {

  std::shared_ptr<MyClass> myPtr1(new MyClass());

  std::shared_ptr<MyClass> myPtr2 = myPtr1;

 

  myPtr1->doSomething(); // 使用 myPtr1 调用成员函数

  myPtr2->doSomething(); // 使用 myPtr2 调用成员函数

 

  // 当 myPtr1 和 myPtr2 都被销毁时，MyClass 对象的内存才会被释放

  return 0;

}

\#include <iostream>

\#include <memory>

 

class Node {

public:

  std::shared_ptr<Node> next;

  std::weak_ptr<Node> prev;

 

  Node() : next(nullptr), prev() {}

};

 

int main() {

  std::shared_ptr<Node> node1 = std::make_shared<Node>();

  std::shared_ptr<Node> node2 = std::make_shared<Node>();

 

  node1->next = node2;

  node2->prev = node1;

 

  // 循环引用，但使用 weak_ptr 避免了内存泄漏

  return 0;

}在这个例子中，node1 和 node2 形成了循环引用。由于 prev 是 weak_ptr，当 node1 和 node2 的 shared_ptr 被销毁时，它们指向的内存也会被正确释放。

-  std::shared_ptr支持引用计数
-  **std::unique_ptr不能共享所有权**
-  std::weak_ptr可以避免循环引用

 

## 泛型编程与标准模板库

面向对象以类作为基础

泛型编程以模板作为基础

共同特点：重用代码

容器、迭代器、算法、迭代器、容器、函数对象

迭代器：内部类

外部类名:内部类名 成员函数名

| **迭代器类型** | **主要用途** | **类比**                             | **典型示例**                                                 |
| -------------- | ------------ | ------------------------------------ | ------------------------------------------------------------ |
| **输入迭代器** | **读取数据** | 程序从外部源（如容器）**读取**数据   | **istream_iterator**（从流读）类似于cin>>x  程序从标准输入流读取数据 |
| **输出迭代器** | **写入数据** | 程序向外部目标（如容器）中“输出”数据 | **ostream_iterator**（向流写）类似于cout<<x  程序向标准输出流输出数据 |

STL 的设计基于泛型编程，这意味着使用模板可以编写出独立于任何特定数据类型的代码。

STL 分为多个组件，包括容器（Containers）、迭代器（Iterators）、算法（Algorithms）、函数对象（Function Objects）和适配器（Adapters）等。

使用 STL 的好处:

- **代码复用**：STL 提供了大量的通用数据结构和算法，可以减少重复编写代码的工作。
- **性能优化**：STL 中的算法和数据结构都经过了优化，以提供最佳的性能。
- **泛型编程**：使用模板，STL 支持泛型编程，使得算法和数据结构可以适用于任何数据类型。
- **易于维护**：STL 的设计使得代码更加模块化，易于阅读和维护。

C++ 标准模板库的核心包括以下重要组件组件：

| **组件**                     | **描述**                                                     |
| ---------------------------- | ------------------------------------------------------------ |
| 容器（Containers）           | 容器是 STL 中最基本的组件之一，提供了各种数据结构，包括向量（vector）、链表（list）、队列（queue）、栈（stack）、集合（set）、映射（map）等。这些容器具有不同的特性和用途，可以根据实际需求选择合适的容器。 |
| 算法（Algorithms）           | STL  提供了大量的算法，用于对容器中的元素进行各种操作，包括排序、搜索、复制、移动、变换等。这些算法在使用时不需要关心容器的具体类型，只需要指定要操作的范围即可。 |
| 迭代器（iterators）          | 迭代器用于遍历容器中的元素，允许以统一的方式访问容器中的元素，而不用关心容器的内部实现细节。STL 提供了多种类型的迭代器，包括随机访问迭代器、双向迭代器、前向迭代器和输入输出迭代器等。 |
| 函数对象（Function Objects） | 函数对象是可以像函数一样调用的对象，可以用于算法中的各种操作。STL 提供了多种函数对象，包括一元函数对象、二元函数对象、谓词等，可以满足不同的需求。 |
| 适配器（Adapters）           | 适配器用于将一种容器或迭代器适配成另一种容器或迭代器，以满足特定的需求。STL 提供了多种适配器，包括栈适配器（stack adapter）、队列适配器（queue adapter）和优先队列适配器（priority queue  adapter）等。 |

这些个组件都带有丰富的预定义函数，帮助我们通过简单的方式处理复杂的任务。



#### 容器

所谓容器就是一种对象，容器里存放到其他类型的对象称为容器里的元素

C++标准库以类模板的形式产生容器类

容器是用来存储数据的序列，它们提供了不同的存储方式和访问模式。

 

STL 中的容器可以分为三类：

1、序列容器：存储元素的序列，允许双向遍历。

- std::vector：动态数组，支持快速随机访问。
- std::deque：双端队列，支持快速插入和删除。
- std::list：链表，支持快速插入和删除，但不支持随机访问。

2、关联容器：存储键值对，每个元素都有一个键（key）和一个值（value），并且通过键来组织元素。

- std::set：集合，不允许重复元素。
- std::multiset：多重集合，允许多个元素具有相同的键。
- std::map：映射，每个键映射到一个值。
- std::multimap：多重映射，存储了键值对（pair），其中键是唯一的，但值可以重复，允许一个键映射到多个值。

3、无序容器（C++11 引入）：哈希表，支持快速的查找、插入和删除。

- std::unordered_set：无序集合。
- std::unordered_multiset：无序多重集合。
- std::unordered_map：无序映射。
- std::unordered_multimap：无序多重映射。

- **有序容器**（如 **std::map**）通常基于**红黑树**（一种平衡二叉搜索树），元素始终按键的严格弱序（默认是 **<** 比较）排序。
- **无序容器**基于**哈希表**（Hash Table），元素通过哈希函数计算存储位置，不保证顺序。

\#include <iostream>

\#include <vector>

using namespace std;

 

int main()

{

  // 创建一个向量存储 int

  vector<int> vec; 

  int i;

 

  // 显示 vec 的原始大小

  cout << "vector size = " << vec.size() << endl;

 

  // 推入 5 个值到向量中

  for(i = 0; i < 5; i++){

   vec.push_back(i);

  }

 

  // 显示 vec 扩展后的大小

  cout << "extended vector size = " << vec.size() << endl;

 

  // 访问向量中的 5 个值

  for(i = 0; i < 5; i++){

   cout << "value of vec [" << i << "] = " << vec[i] << endl;

  }

 

  // 使用迭代器 iterator 访问值

  vector<int>::iterator v = vec.begin();

  while( v != vec.end()) {

   cout << "value of v = " << *v << endl;

   v++;

  }

 

  return 0;

}

**size** 是当前 vector 容器真实占用的大小，也就是容器当前拥有多少个容器。

**capacity** 是指在发生 realloc 前能允许的最大元素数，即预分配的内存空间。

以vector为例，我们都知道可以用reserve()和resize()函数来为容器预留空间或者调整它的大小。

不过从它俩的名字上可以看出区别：

reserve()：serve是“保留”的词根，所以是用来保留，预留容量的，并不改变容器的有效元素个数。

resize()：size是“大小”的意思，它主要用来调整容易有效元素的个数，有时候也会造成容量变大。

 

先解释两个概念：

**容量**：即capacity，是指容器在自由内存中获得了多大的存储空间，容量为100并不代表容器就有100个元素，可能容量只有10个，剩下的90个都是闲置的未定义内存空间。

**大小**：即size，指的是容器中实际元素的个数，大小为100就代表容器有100个已经存在的元素。

 

当然，这两个属性分别对应两个方法：**resize ()**。

使用 **resize()** 容器内的对象内存空间是真正存在的。

使用 **reserve()** 仅仅只是修改了 capacity 的值，容器内的对象并没有真实的内存空间(空间是"野"的)。

此时切忌使用 **[]** 操作符访问容器内的对象，很可能出现数组越界的问题。

\#include <iostream>

\#include <vector>

 

using std::vector;

int main(void)

{

  vector<int> v;

  std::cout<<"v.size() == " << v.size() << " v.capacity() = " << v.capacity() << std::endl;

  v.reserve(10);

  std::cout<<"v.size() == " << v.size() << " v.capacity() = " << v.capacity() << std::endl;

  v.resize(10);

  v.push_back(0);

  std::cout<<"v.size() == " << v.size() << " v.capacity() = " << v.capacity() << std::endl;

 

  return 0;

}

![img](data:image/png;base64,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)

| **特性**     | **#include**   | **模块（import）**   |
| ------------ | -------------- | -------------------- |
| 编译速度     | 慢（重复解析） | 快（二进制接口复用） |
| 命名空间污染 | 严重           | 隔离性好             |
| 依赖管理     | 隐式           | 显式                 |
| 宏泄漏       | 是             | 否                   |
| 标准库支持   | 全部头文件     | C++23  起逐步模块化  |

#### 迭代器

C++ 标准库中的 <iterator> 头文件提供了一组工具，用于遍历容器中的元素。迭代器是 C++ 标准模板库（STL）中的核心概念之一，它允许程序员以统一的方式访问容器中的元素，而不需要关心容器的具体实现细节。

迭代器是一个对象，它提供了一种方法来遍历容器中的元素。迭代器可以被视为指向容器中元素的指针，但它比指针更加灵活和强大。迭代器可以用于访问、修改容器中的元素，并且可以与 STL 算法一起使用。

迭代器主要分为以下几类：

1. **输入迭代器（Input Iterator）**：只能进行单次读取操作，不能进行写入操作。
2. **输出迭代器（Output Iterator）**：只能进行单次写入操作，不能进行读取操作。
3. **正向迭代器（Forward Iterator）**：可以进行读取和写入操作，并且可以向前移动。
4. **双向迭代器（Bidirectional Iterator）**：除了可以进行正向迭代器的所有操作外，还可以向后移动。
5. **随机访问迭代器（Random Access Iterator）**：除了可以进行双向迭代器的所有操作外，还可以进行随机访问，例如通过下标访问元素。

每种容器类型都定义了自己的迭代器类型，如vector:
 vector<int>::iterator iter;这条语句定义了一个名为iter的变量，它的数据类型是由vector<int>定义的iterator类型。

\#include <iterator>

迭代器是一种泛型指针对象，可以通过迭代器访问所在未知元素，也可以通过迭代器操作更新位置。



 

 

// 使用迭代器遍历容器

for (ContainerType::iterator it = container.begin(); it != container.end(); ++it) {

  // 访问元素 *it

}

\#include <iostream>

\#include <vector>

\#include <iterator>

 

int main() {

  // 创建一个 vector 容器并初始化

  std::vector<int> vec = {1, 2, 3, 4, 5};

 

  // 使用迭代器遍历 vector

  for (std::vector<int>::iterator it = vec.begin(); it != vec.end(); ++it) {

​    std::cout << *it << " ";

  }

  std::cout << std::endl;

 

  // 使用 auto 关键字简化迭代器类型

  for (auto it = vec.begin(); it != vec.end(); ++it) {

​    std::cout << *it << " ";

  }

  std::cout << std::endl;

 

  // 使用 C++11 范围 for 循环

  for (int elem : vec) {

​    std::cout << elem << " ";

  }

  std::cout << std::endl;

 

  return 0;

}通过使用 <iterator> 头文件，我们可以方便地遍历 C++ STL 容器中的元素。迭代器提供了一种统一的接口，使得我们可以在不同的容器之间切换，而不需要改变遍历的代码。这大大提高了代码的可重用性和可维护性。

vector<int> ivec(10,1);

for(vector<int>::iterator iter=ivec.begin();iter!=ivec.end();++iter)

{

*iter=2; //使用 * 访问迭代器所指向的元素

}

const_iterator:

只能读取容器中的元素，而不能修改。

for(vector<int>::const_iterator citer=ivec.begin();citer!=ivec.end();citer++)

{

cout<<*citer;

//*citer=3; error

}

vector<int>::const_iterator 和 const vector<int>::iterator的区别

const vector<int>::iterator newiter=ivec.begin();

*newiter=11; //可以修改指向容器的元素

 vector 和deque提供的是RandomAccessIterator，list提供的是BidirectionalIterator，set和map提供的 iterators是 ForwardIterator

##### 关于STL中iterator迭代器的操作如下：

(1)所有迭代器

p++               后置自增迭代器

++p               前置自增迭代器

(2)输入迭代器

*p                 复引用迭代器，作为右值

p=p1               将一个迭代器赋给另一个迭代器

p==p1              比较迭代器的相等性

p!=p1              比较迭代器的不等性

(3)输出迭代器

*p                 复引用迭代器，作为左值

p=p1               将一个迭代器赋给另一个迭代器

(4)正向迭代器

提供输入输出迭代器的所有功能

(5)双向迭代器

--p                前置自减迭代器

p--                后置自减迭代器

(6)随机迭代器

p+=i               将迭代器递增i位

p-=i                将迭代器递减i位

p+i                在p位加i位后的迭代器

p-i                 在p位减i位后的迭代器

p[i]                返回p位元素偏离i位的元素引用

p<p1               如果迭代器p的位置在p1前，返回true，否则返回false

p<=p1              p的位置在p1的前面或同一位置时返回true，否则返回false

p>p1               如果迭代器p的位置在p1后，返回true，否则返回false

p>=p1              p的位置在p1的后面或同一位置时返回true，否则返回false

  只有顺序容器和关联容器支持迭代器遍历，各容器支持的迭代器的类别如下：

容器         支持的迭代器类别      容器        支持的迭代器类别      容器         支持的迭代器类别

vector       随机访问           deque       随机访问            list          双向

set          双向              multiset      双向              map         双向

multimap     双向               stack        不支持            queue       不支持

priority_queue  不支持

 

**![img](data:image/png;base64,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)**

### Array容器

std::array 是 C++ 标准库中的一个模板类，它定义在 <array> 头文件中。std::array 模板类提供了一个固定大小的数组，其大小在编译时确定，并且不允许动态改变。

**语法**

std::array 的基本语法如下：

\#include <array>

std::array<T, N> array_name;

- T 是数组中元素的类型。
- N 是数组的大小，必须是一个非负整数。

以下是 <array> 中的一些常用成员函数：

| **函数**              | **说明**                         |
| --------------------- | -------------------------------- |
| at(size_t  pos)       | 返回指定位置的元素，带边界检查   |
| operator[]            | 返回指定位置的元素，不带边界检查 |
| front()               | 返回数组的第一个元素             |
| back()                | 返回数组的最后一个元素           |
| data()                | 返回指向数组数据的指针           |
| size()                | 返回数组大小（固定不变）         |
| fill(const  T& value) | 将数组所有元素设置为指定值       |
| swap(array&  other)   | 交换两个数组的内容               |
| begin() / end()       | 返回数组的起始/结束迭代器        |

 

### vector 容器

**基本特性:**

- **动态大小**：vector 的大小可以根据需要自动增长和缩小。
- **连续存储**：vector 中的元素在内存中是连续存储的，这使得访问元素非常快速。
- **可迭代**：vector 可以被迭代，你可以使用循环（如 for 循环）来访问它的元素。
- **元素类型**：vector 可以存储任何类型的元素，包括内置类型、对象、指针等。

 

**创建 Vector**

创建一个 vector 可以像创建其他变量一样简单：

std::vector<int> myVector; // 创建一个存储整数的空 vector

这将创建一个空的整数向量,也可以在创建时指定初始大小和初始值：

std::vector<int> myVector(5); // 创建一个包含 5 个整数的 vector，每个值都为默认值（0）

std::vector<int> myVector(5, 10); // 创建一个包含 5 个整数的 vector，每个值都为 10

或：

std::vector<int> vec; // 默认初始化一个空的 vector

std::vector<int> vec2 = {1, 2, 3, 4}; // 初始化一个包含元素的 vector

**添加元素**

可以使用 push_back 方法向 vector 中添加元素：

myVector.push_back(7); // 将整数 7 添加到 vector 的末尾

**访问元素**

可以使用下标操作符 [] 或 at() 方法访问 vector 中的元素：

int x = myVector[0]; // 获取第一个元素

int y = myVector.at(1); // 获取第二个元素

**获取大小**

可以使用 size() 方法获取 vector 中元素的数量：

int size = myVector.size(); // 获取 vector 中的元素数量

**迭代访问**

可以使用迭代器遍历 vector 中的元素：

for (auto it = myVector.begin(); it != myVector.end(); ++it) {

  std::cout << *it << " ";

}

或者使用范围循环：

for (int element : myVector) {

  std::cout << element << " ";

}

**删除元素**

可以使用 erase() 方法删除 vector 中的元素：

myVector.erase(myVector.begin() + 2); // 删除第三个元素

**清空 Vector**

可以使用 clear() 方法清空 vector 中的所有元素：

myVector.clear(); // 清空 vector

嵌套vector

 // 打印乘法表

  for (vector<vector<int>>::iterator iter = outer.begin(); iter != outer.end(); ++iter) {

​    // 获取当前行的向量

​    vector<int> inner = *iter;

​    for (vector<int>::iterator it = inner.begin(); it != inner.end(); ++it)

​      // 打印当前元素，设置宽度为 4 个字符，确保对齐

​      cout << setw(4) << *it;

​    // 打印换行符，开始新的一行

​    cout << endl;

  }

 

| **函数**                   | **说明**                         |
| -------------------------- | -------------------------------- |
| push_back(const  T& val)   | 在末尾添加元素                   |
| pop_back()                 | 删除末尾元素                     |
| at(size_t  pos)            | 返回指定位置的元素，带边界检查   |
| operator[]                 | 返回指定位置的元素，不带边界检查 |
| front()                    | 返回第一个元素                   |
| back()                     | 返回最后一个元素                 |
| data()                     | 返回指向底层数组的指针           |
| size()                     | 返回当前元素数量                 |
| capacity()                 | 返回当前分配的容量               |
| reserve(size_t  n)         | 预留至少 n 个元素的存储空间      |
| resize(size_t  n)          | 将元素数量调整为 n               |
| clear()                    | 清空所有元素                     |
| insert(iterator  pos, val) | 在指定位置插入元素               |
| erase(iterator  pos)       | 删除指定位置的元素               |
| begin() / end()            | 返回起始/结束迭代器              |

Reserve成员函数内部用于保证向量内部空间，在程序可预测所需向量时可一步到位建立内部空间，reserve不影响向量内部实际元素个数，不会导致成员函数size返回的向量内元素个数

**关键特性：**

1. **不影响元素个数**：
   - **reserve(n)** 只是预分配内存空间，不会改变向量中实际存储的元素数量。
   - **size()** 返回的是当前向量中实际存在的元素个数，**reserve** 不会影响这个值。
   - **capacity()** 返回的是当前向量已分配的内存空间能容纳的元素数量（≥ **size()**）。

\#include <iostream>

\#include <vector>

 

int main() {

  std::vector<int> vec;

 

  // 预分配空间（不影响 size）

  vec.reserve(100);

  std::cout << "After reserve(100):" << std::endl;

  std::cout << " size() = " << vec.size() << std::endl;   // 输出 0

  std::cout << " capacity() = " << vec.capacity() << std::endl; // 输出 100

 

  // 添加元素

  vec.push_back(42);

  std::cout << "After push_back:" << std::endl;

  std::cout << " size() = " << vec.size() << std::endl;   // 输出 1

  std::cout << " capacity() = " << vec.capacity() << std::endl; // 输出 100

}

### Deque容器

 

在 C++中，<deque> 是标准模板库（STL）的一部分，它提供了双端队列（double-ended queue）的实现。

双端队列是一种允许在两端进行插入和删除操作的线性数据结构。

<deque> 的全称是 "double-ended queue"，它在C++中以模板类的形式存在，允许存储任意类型的数据。

<deque> 是一个动态数组，它提供了快速的随机访问能力，同时允许在两端进行高效的插入和删除操作。这使得 <deque> 成为处理需要频繁插入和删除元素的场景的理想选择。

多个分段的内存块中，段内连续，段间不需要连续

**语法**

在 C++ 中，使用 <deque> 需要包含头文件 #include <deque>。以下是 <deque> 的基本语法：

\#include <iostream>

\#include <deque>

 

int main() {

  std::deque<int> myDeque; // 创建一个整数类型的双端队列

  // 接下来可以进行插入、删除等操作

  return 0;

}

**常用操作**

下面是 std::deque 容器的一些常用成员函数：

| **函数名称**                          | **功能描述**                                 |
| ------------------------------------- | -------------------------------------------- |
| deque()                               | 默认构造函数，创建一个空的 deque 容器。      |
| deque(size_type  n)                   | 创建一个包含 n 个默认值元素的 deque 容器。   |
| deque(size_type  n, const T& value)   | 创建一个包含 n 个值为 value 的 deque 容器。  |
| deque(initializer_list<T>  il)        | 使用初始化列表 il 构造 deque 容器。          |
| operator=                             | 赋值操作符，赋值给 deque 容器。              |
| assign()                              | 用新值替换 deque 容器中的所有元素。          |
| at(size_type  pos)                    | 返回 pos 位置的元素，并进行范围检查。        |
| operator[](size_type  pos)            | 返回 pos 位置的元素，不进行范围检查。        |
| front()                               | 返回第一个元素的引用。                       |
| back()                                | 返回最后一个元素的引用。                     |
| begin()                               | 返回指向第一个元素的迭代器。                 |
| end()                                 | 返回指向末尾元素后一位置的迭代器。           |
| rbegin()                              | 返回指向最后一个元素的逆向迭代器。           |
| rend()                                | 返回指向第一个元素之前位置的逆向迭代器。     |
| empty()                               | 检查容器是否为空。                           |
| size()                                | 返回容器中的元素个数。                       |
| max_size()                            | 返回容器可容纳的最大元素个数。               |
| clear()                               | 清除容器中的所有元素。                       |
| insert(iterator  pos, const T& value) | 在 pos 位置插入 value 元素。                 |
| erase(iterator  pos)                  | 移除 pos 位置的元素。                        |
| push_back(const  T& value)            | 在容器末尾添加 value 元素。                  |
| pop_back()                            | 移除容器末尾的元素。                         |
| push_front(const  T& value)           | 在容器前端添加 value 元素。                  |
| pop_front()                           | 移除容器前端的元素。                         |
| resize(size_type  count)              | 调整容器大小为 count，多出部分用默认值填充。 |
| swap(deque&  other)                   | 交换两个 deque 容器的内容。                  |
| get_allocator()                       | 返回一个用于构造双端队列的分配器对象的副本。 |

 

### List

C++ 标准库提供了丰富的功能，其中 <list> 是一个非常重要的容器类，用于存储元素集合，支持双向迭代器。

<list> 是 C++ 标准模板库（STL）中的一个序列容器，它允许在容器的任意位置快速插入和删除元素。与数组或向量（<vector>）不同，<list> 不需要在创建时指定大小，并且可以在任何位置添加或删除元素，而不需要重新分配内存。

| **函数**                   | **说明**                  |
| -------------------------- | ------------------------- |
| push_back(const  T& val)   | 在链表末尾添加元素        |
| push_front(const  T& val)  | 在链表头部添加元素        |
| pop_back()                 | 删除链表末尾的元素        |
| pop_front()                | 删除链表头部的元素        |
| insert(iterator  pos, val) | 在指定位置插入元素        |
| erase(iterator  pos)       | 删除指定位置的元素        |
| clear()                    | 清空所有元素              |
| size()                     | 返回链表中的元素数量      |
| empty()                    | 检查链表是否为空          |
| front()                    | 返回链表第一个元素        |
| back()                     | 返回链表最后一个元素      |
| remove(const  T& val)      | 删除所有等于指定值的元素  |
| sort()                     | 对链表中的元素进行排序    |
| merge(list&  other)        | 合并另一个已排序的链表    |
| reverse()                  | 反转链表                  |
| begin() / end()            | 返回链表的起始/结束迭代器 |

 

| **特性**          | **std::list**                | **std::vector**              | **std::deque**               |
| ----------------- | ---------------------------- | ---------------------------- | ---------------------------- |
| **内存结构**      | 非连续内存，双向链表         | 连续内存                     | 分段连续内存                 |
| **访问性能**      | 顺序访问较快，随机访问慢     | 随机访问快                   | 末尾和头部访问都快           |
| **插入/删除性能** | 任意位置插入、删除快         | 末尾插入快，中间位置慢       | 头尾插入、删除快             |
| **适用场景**      | 频繁在中间插入/删除          | 需要高效随机访问             | 需要在头尾快速插入/删除      |
| **迭代器稳定性**  | 稳定，元素插入或删除不会失效 | 插入、删除可能导致迭代器失效 | 插入、删除可能导致迭代器失效 |

**注意事项**

- <list> 的元素是按插入顺序存储的，而不是按元素值排序。
- 由于 <list> 的元素存储在不同的内存位置，所以它不适合需要随机访问的场景。
- 与向量相比，<list> 的内存使用效率较低，因为每个元素都需要额外的空间来存储指向前后元素的指针。

### Stack

<stack> 是 C++ 标准模板库（STL）的一部分，它实现了一个后进先出（LIFO，Last In First Out）的数据结构。这种数据结构非常适合于需要"最后添加的元素最先被移除"的场景。

<stack> 容器适配器提供了一个栈的接口，它基于其他容器（如 deque 或 vector）来实现。栈的元素是线性排列的，但只允许在一端（栈顶）进行添加和移除操作。

**基本操作**

- push(): 在栈顶添加一个元素。
- pop(): 移除栈顶元素。
- top(): 返回栈顶元素的引用，但不移除它。
- empty(): 检查栈是否为空。
- size(): 返回栈中元素的数量。

- <stack> 不提供直接访问栈中元素的方法，只能通过 top() 访问栈顶元素。
- 尝试在空栈上调用 top() 或 pop() 将导致未定义行为。
- <stack> 的底层容器可以是任何支持随机访问迭代器的序列容器，如 vector 或 deque。

 

### Queue

C++ 标准库中的 <queue> 头文件提供了队列（Queue）数据结构的实现。队列是一种先进先出（FIFO, First In First Out）的数据结构，它允许在一端添加元素（称为队尾），并在另一端移除元素（称为队首）。

队列是一种线性数据结构，它遵循以下规则：

- 元素只能从队尾添加。
- 元素只能从队首移除。

**语法**

在 C++ 中，队列的语法如下：

\#include <queue>

 

// 声明队列

std::queue<Type> q;

这里 Type 是队列中存储元素的数据类型。

**常用操作**

队列提供了以下常用操作：

- empty(): 检查队列是否为空。
- size(): 返回队列中的元素数量。
- front(): 返回队首元素的引用。
- back(): 返回队尾元素的引用。
- push(): 在队尾添加一个元素。
- pop(): 移除队首元素。

**注意事项**

- 队列不允许随机访问元素，即不能直接通过索引访问队列中的元素。
- 队列的实现通常使用链表或动态数组，这取决于具体的实现。

 

### String

C++ 标准库（Standard Template Library, STL）是 C++ 的核心组成部分之一，提供了丰富的数据结构和算法。

<string> 是 C++ 标准库中用于处理字符串的头文件。

在 C++ 中，字符串是由字符组成的序列。<string> 头文件提供了 std::string 类，它是对 C 风格字符串的封装，提供了更安全、更易用的字符串操作功能。

| **函数名**          | **描述**                                       | **示例代码**                                  |
| ------------------- | ---------------------------------------------- | --------------------------------------------- |
| size()              | 返回字符串的长度（字符数）。                   | std::cout  << str.size();                     |
| length()            | 与 size() 相同，返回字符串的长度。             | std::cout  << str.length();                   |
| empty()             | 判断字符串是否为空。                           | std::cout  << (str.empty() ? "Yes" : "No");   |
| operator[]          | 访问字符串中指定位置的字符。                   | std::cout  << str[0];                         |
| at()                | 访问字符串中指定位置的字符（带边界检查）。     | std::cout  << str.at(0);                      |
| substr()            | 返回从指定位置开始的子字符串。                 | std::string  sub = str.substr(0, 5);          |
| find()              | 查找子字符串在字符串中的位置。                 | std::cout  << str.find("sub") << std::endl;   |
| rfind()             | 从字符串末尾开始查找子字符串的位置。           | std::cout  << str.rfind("sub") << std::endl;  |
| replace()           | 替换字符串中的部分内容。                       | str.replace(pos,  length, "new_substring");   |
| append()            | 在字符串末尾添加内容。                         | str.append("  more");                         |
| insert()            | 在指定位置插入内容。                           | str.insert(pos,  "inserted");                 |
| erase()             | 删除指定位置的字符或子字符串。                 | str.erase(pos,  length);                      |
| clear()             | 清空字符串。                                   | str.clear();                                  |
| c_str()             | 返回 C 风格的字符串（以 null 结尾）。          | const  char* cstr = str.c_str();              |
| data()              | 返回指向字符数据的指针（C++11 及之后的版本）。 | const  char* data = str.data();               |
| compare()           | 比较两个字符串。                               | int  result = str.compare("other");           |
| find_first_of()     | 查找第一个匹配任意字符的位置。                 | size_t  pos = str.find_first_of("aeiou");     |
| find_last_of()      | 查找最后一个匹配任意字符的位置。               | size_t  pos = str.find_last_of("aeiou");      |
| find_first_not_of() | 查找第一个不匹配任意字符的位置。               | size_t  pos = str.find_first_not_of("aeiou"); |
| find_last_not_of()  | 查找最后一个不匹配任意字符的位置。             | size_t  pos = str.find_last_not_of("aeiou");  |

 

### Forwrdlist

 

### Typeinfo

C++ 标准库 <typeinfo>

在 C++ 中，<typeinfo> 是标准库的一部分，它提供了运行时类型识别（RTTI，Run-Time Type Identification）功能。RTTI 允许程序在运行时确定对象的类型。这是通过使用 typeid 运算符和 type_info 类实现的。

 

type_info 类是一个抽象基类，它提供了关于类型信息的接口。每个类型都有一个与之关联的 type_info 对象，可以通过 typeid 运算符访问。

 

语法

<typeinfo> 相关的主要语法：

 

typeid 运算符：用于获取对象的类型信息。

type_info 类：包含类型信息的类。

类型信息类 type_info

typeinfo 头文件提供了对类型信息的运行时支持。它主要包含两个核心组件：std::type_info 类和 typeid 运算符。typeinfo 允许程序在运行时获取对象的类型信息，这在多态和类型安全的代码中非常有用。以下是对 typeinfo 的详细介绍：

 

std::type_info 类

std::type_info 类是 typeinfo 头文件的核心类，用于描述一个类型。它提供了多个成员函数用于查询类型的信息。常用成员函数如下：

 

const char* name() const noexcept; 返回一个指向类型名称的 C 字符串指针。注意，这个名称不一定是人类可读的类型名，其格式由编译器实现决定。

 

bool before(const std::type_info& rhs) const noexcept; 按照某种顺序比较两个 type_info 对象，返回当前对象是否在 rhs 之前。

 

bool operator==(const std::type_info& rhs) const noexcept; 比较两个 type_info 对象是否表示相同的类型。

 

bool operator!=(const std::type_info& rhs) const noexcept; 比较两个 type_info 对象是否表示不同的类型。

 

typeid 运算符

typeid 运算符用于在运行时获取类型信息。typeid 可以作用于对象（带有多态行为的指针或引用）或类型（无需实例化对象）。

 

typeid(object)：返回一个 std::type_info 对象，表示 object 的动态类型。如果 object 是一个多态类型（即包含虚函数），则 typeid 会返回该对象的实际类型。

typeid(T)：返回一个 std::type_info 对象，表示类型 T。

实例

下面是一个使用 <typeinfo> 的简单示例：

 

实例

\#include <iostream>

\#include <typeinfo>

 

class Base {

public:

  virtual void show() { std::cout << "Base show" << std::endl; }

};

 

class Derived : public Base {

public:

  void show() override { std::cout << "Derived show" << std::endl; }

};

 

int main() {

  Base* basePtr = new Derived();

  Base* basePtr2 = new Base();

 

  std::cout << "Type of basePtr: " << typeid(*basePtr).name() << std::endl;

  std::cout << "Type of basePtr2: " << typeid(*basePtr2).name() << std::endl;

 

  if (typeid(*basePtr) == typeid(Derived)) {

​    std::cout << "basePtr is of type Derived" << std::endl;

  } else {

​    std::cout << "basePtr is not of type Derived" << std::endl;

  }

 

  delete basePtr;

  delete basePtr2;

 

  return 0;

}

输出结果:

 

Type of basePtr: 9Derived // 注意：typeid的name()返回的类型名称可能因编译器而异

Type of basePtr2: 8Base   // 同上

basePtr is of type Derived

注意事项

RTTI 功能依赖于编译器的实现，因此 typeid 运算符返回的类型名称可能因编译器而异。

使用 RTTI 可能会对程序性能产生一定影响，因为它需要在运行时进行类型检查。

RTTI 只适用于多态类型，即具有虚函数的类。

<typeinfo> 提供了一种在运行时识别对象类型的方法，这对于实现多态和类型安全非常有用。然而，开发者应该谨慎使用 RTTI，以避免不必要的性能开销和潜在的类型错误。

 

### Map

 

在 C++ 中，<map> 是标准模板库（STL）的一部分，它提供了一种关联容器，用于存储键值对（key-value pairs）。

map 容器中的元素是按照键的顺序自动排序的，这使得它非常适合需要快速查找和有序数据的场景。

基于平衡二叉树（红黑树）

**定义和特性**

- **键值对**：map 存储的是键值对，其中每个键都是唯一的。
- **排序**：map 中的元素按照键的顺序自动排序，通常是升序。
- **唯一性**：每个键在 map 中只能出现一次。
- **双向迭代器**：map 提供了双向迭代器，可以向前和向后遍历元素。

**基本语法**

包含头文件:

\#include <map>

声明 map 容器:

std::map<key_type, value_type> myMap;

- key_type 是键的类型。
- value_type 是值的类型。

插入元素:

myMap[key] = value;

访问元素:

value = myMap[key];

遍历 map:

for (std::map<key_type, value_type>::iterator it = myMap.begin(); it != myMap.end(); ++it) {

  std::cout << it->first << " => " << it->second << std::endl;

}

 

 

### 算法库 <algorithm>

C++ 标准库中的 <algorithm> 头文件提供了一组用于操作容器（如数组、向量、列表等）的算法。这些算法包括排序、搜索、复制、比较等，它们是编写高效、可重用代码的重要工具。

<algorithm> 头文件定义了一组模板函数，这些函数可以应用于任何类型的容器，只要容器支持迭代器。这些算法通常接受两个或更多的迭代器作为参数，表示操作的起始和结束位置。

**语法**

大多数 <algorithm> 中的函数都遵循以下基本语法：

algorithm_name(container.begin(), container.end(), ...);

这里的 container 是一个容器对象，begin() 和 end() 是容器的成员函数，返回指向容器开始和结束的迭代器。

**std::for_each**: 对区间内的每个元素执行操作。

std::for_each(vec.begin(), vec.end(), [](int& x) { x += 1; });

**1. 排序算法**

函数：sort

定义：对容器中的元素进行排序。

语法：

sort(container.begin(), container.end(), compare_function);

**2. 搜索算法**

函数：find

定义：在容器中查找与给定值匹配的第一个元素。

语法：

auto it = find(container.begin(), container.end(), value);

**3. 复制算法**

函数：copy

定义：将一个范围内的元素复制到另一个容器或数组。

语法：

copy(source_begin, source_end, destination_begin);

**4. 比较算法**

函数：equal

定义：比较两个容器或两个范围内的元素是否相等。

语法：

bool result = equal(first1, last1, first2);

或

bool result = equal(first1, last1, first2, compare_function);

**5. 修改算法**

**std::reverse**: 反转区间内的元素顺序。

std::reverse(vec.begin(), vec.end());

**std::fill**: 将指定区间内的所有元素赋值为某个值。

std::fill(vec.begin(), vec.end(), 0); // 所有元素设为 0

**std::replace**: 将区间内的某个值替换为另一个值。

std::replace(vec.begin(), vec.end(), 1, 99); // 将所有 1 替换为 99

**std::copy**: 将区间内的元素复制到另一个区间。

std::vector<int> vec2(6);

std::copy(vec.begin(), vec.end(), vec2.begin());

### 函数对象

当一个类重载了 **operator()**，其实例就被称为**函数对象（Function Object）**或**仿函数（Functor）**。

用户用自定义对象通过运算符（）来调用函数

C++规定调用运算符只能重载为类的成员函数

返回值类型 operator() (形参表)

 

 

class MyFunctor {

public:

  // 重载 operator()

  return_type operator()(parameters) {

​    // 实现逻辑

  }

};

**class Adder {**

**public:**

  **int operator()(int a, int b) {**

​    **return a + b;**

  **}**

**};**

 

**int main() {**

  **Adder add;     // 创建函数对象**

  **int result = add(3, 4); // 调用 operator()，输出 7**

  **std::cout << result;**

**}**

 

**许多 STL 算法（如 std::sort、std::transform）接受函数对象作为参数，比函数指针更灵活。
 例如，用仿函数自定义排序规则：**

**class Compare {**

**public:**

  **bool operator()(int a, int b) {**

​    **return a > b; \*//\* \*降序排序\***

  **}**

**};**

 

**int main() {**

  **std::vector<int> v = {5, 2, 8, 1};**

  **std::sort(v.begin(), v.end(), Compare());**

  ***// v\* \*变为 {8, 5, 2, 1}\***

**}**

 

**#include <iostream>**

**#include <vector>**

**#include <algorithm>**

**using namespace std;**

 

**class obj**

**{**

**public:**

  **obj(int a_) : a(a_) {}**

 

  **// 成员函数**

  **void show() const**

  **{**

​    **cout << "Value of a: " << a << endl;**

  **}**

 

  **// 成员函数重载**

  **int getA() const**

  **{**

​    **return a;**

  **}**

 

  **// 比较类应该定义为public**

  **class compare**

  **{**

  **public: // 必须添加public，否则sort无法访问operator()**

​    **bool operator()(const obj &lhs, const obj &rhs) const**

​    **{**

​      **return lhs.getA() < rhs.getA();**

​    **}**

  **};**

 

**private:**

  **int a;**

**};**

 

**int main()**

**{**

  **vector<obj> v;**

  **v.push_back(obj(3)); // 调整顺序以测试排序**

  **v.push_back(obj(1));**

  **v.push_back(obj(2));**

 

  **// 使用成员比较类**

  **sort(v.begin(), v.end(), obj::compare()); // 创建compare的临时对象**

  

  **for (const auto &o : v)**

  **{**

​    **o.show();**

  **}**

 

  **return 0;**

**}**

**那么，有以下三种方式进行比较：**

**1、**  

**Obj类中包含compare类**

 **class compare**

  **{**

  **public: // 必须添加public，否则sort无法访问operator()**

​    **bool operator()(const obj &lhs, const obj &rhs) const**

​    **{**

​      **return lhs.getA() < rhs.getA();**

​    **}**

  **};**

  **sort(v.begin(), v.end(), obj::compare()); // 创建compare的临时对象**

**2**

**考虑将比较运算符重载为成员函数：如果obj类需要频繁比较，可以直接重载operator<：**

**Obj类中**

**bool operator<(const obj& rhs) const {**

  **return a < rhs.a;**

**}**

**然后直接调用：**

**sort(v.begin(), v.end());**

**3、**

**Bool compare(const obj &r1,const obj&r2)**

**{**

**Return r1.a<r2.a**

**}**

**然后调用**

**Sort(v.begin,v,end(),compare)**

**4lambda表达式**

**sort(v.begin(), v.end(), [](const obj& a, const obj& b) {**

  **return a.a < b.a;**

**});**

 

 

#### (1) Lambda 表达式是简化的函数对象

**C++11 的 Lambda 本质上是一个匿名函数对象：**

**auto adder = [](int a, int b) { return a + b; };**

**std::cout << adder(3, 4); \*//\* \*输出 7\***

**编译器会将 Lambda 转换为类似下面的类：**

**class __AnonymousLambda {**

**public:**

  **int operator()(int a, int b) const {**

​    **return a + b;**

  **}**

**};**

#### (2) 标准库中的函数对象

**<functional> 头文件提供了许多预定义的函数对象：**

**#include <functional>**

**std::plus<int> add;   \*//\* \*仿函数，等价于 operator+\***

**std::cout << add(3, 4); \*//\* \*输出 7\***

#### sort排序

**(1) 默认排序（升序：std::less）**

**#include <algorithm>**

**#include <functional>**

**#include <vector>**

 

**int main() {**

  **std::vector<int> v = {5, 2, 8, 1};**

  ***//\* \*显式使用 std::less（默认行为，可省略）\***

  **std::sort(v.begin(), v.end(), std::less<int>());**

  ***// v\* \*变为 {1, 2, 5, 8}\***

**}**

- **std::less<int>() 是一个函数对象，内部重载了 operator()，比较两个元素是否满足 a <     b。**
- **如果省略第三个参数，std::sort 默认使用 std::less。**

**(2) 降序排序（std::greater）**

**std::sort(v.begin(), v.end(), std::greater<int>());**

#### Funcitional模板

std::function 是一个模板类，可以存储、调用和复制任何可调用对象，比如函数、lambda 表达式或函数对象。

 

实例

\#include <iostream>

\#include <functional>

 

void greet() {

  std::cout << "Hello, World!" << std::endl;

}

 

int main() {

  std::function<void()> f = greet; // 使用函数

  f(); // 输出: Hello, World!

 

  std::function<void()> lambda = []() {

​    std::cout << "Hello, Lambda!" << std::endl;

  };

  lambda(); // 输出: Hello, Lambda!

 

  return 0;

}

std::bind 允许我们创建一个可调用对象，它在调用时会将给定的参数绑定到一个函数或函数对象。

 

实例

\#include <iostream>

\#include <functional>

 

int add(int a, int b) {

  return a + b;

}

 

int main() {

  auto bound_add = std::bind(add, 5, std::placeholders::_1);

  std::cout << bound_add(10) << std::endl; // 输出: 15

 

  return 0;

}

 

在这个例子中，std::placeholders::_1 是一个占位符，它在调用 bound_add 时会被实际的参数替换。

**#include <iostream>**

**#include <vector>**

**#include <algorithm>**

**#include <functional>**

 

**bool compare(int a, int b) {**

  **return a < b;**

**}**

 

**int main() {**

  **std::vector<int> v = {5, 3, 9, 1, 4};**

  **std::sort(v.begin(), v.end(), compare); // 使用自定义比较函数**

  **for (int i : v) {**

​    **std::cout << i << " "; // 输出: 1 3 4 5 9**

  **}**

 

  **std::sort(v.begin(), v.end(), std::less<int>()); // 使用标准库比较函数对象**

  **for (int i : v) {**

​    **std::cout << i << " "; // 输出: 1 3 4 5 9**

  **}**

 

  **return 0;**

**}**

#### Lambda表达式

c++在c++11标准中引入了[lambda表达式](https://zhida.zhihu.com/search?content_id=173533885&content_type=Article&match_order=1&q=lambda表达式&zhida_source=entity)，一般用于定义匿名函数，使得代码更加灵活简洁。lambda表达式与普通函数类似，也有参数列表、返回值类型和函数体，只是它的定义方式更简洁，并且可以在函数内部定义。

**什么是Lambda表达式**

最常见的lambda的表达式写法如下

auto plus = [] (int v1, int v2) -> int { return v1 + v2; }

int sum = plus(1, 2);

[capture-list] (parameters) mutable -> return-type { body }

-  **[capture]**：捕捉列表。捕捉列表总是出现在     lambda 表达式的开始处。事实上，[] 是     lambda 引出符。编译器根据该引出符判断接下来的代码是否是 lambda 函数。捕捉列表能够捕捉上下文中的变量供 lambda 函数使用。
-  (parameters)：参数列表。与普通函数的参数列表一致。如果不需要参数传递，则可以连同括号 () 一起省略。
-  **mutable**：mutable 修饰符。默认情况下，lambda 函数总是一个 const 函数，mutable 可以取消其常量性。在使用该修饰符时，参数列表不可省略（即使参数为空）。
-  **->return_type**：返回类型。用追踪返回类型形式声明函数的返回类型。出于方便，不需要返回值的时候也可以连同符号 -> 一起省略。此外，在返回类型明确的情况下，也可以省略该部分，让编译器对返回类型进行推导。
-  **{statement}**：函数体。内容与普通函数一样，不过除了可以使用参数之外，还可以使用所有捕获的变量。

在 lambda 函数的定义式中，参数列表和返回类型都是可选部分，而捕捉列表和函数体都可能为空，C++ 中最简单的 lambda 函数只需要声明为：

[]{};

 

**1. (parameters)：Lambda 的参数表**

**(parameters) 表示 Lambda 函数的参数列表，和普通函数的参数列表语法一致。**

**如果没有参数，可以写成 ()，表示无参 Lambda：**

**auto func = []() { return 42; }; // 无参 Lambda**

**如果 Lambda 不需要参数，() 可以省略：**

**auto func = [] { return 42; };  // 等效于上一行（省略 ()）**

**2. mutable 和 -> return-type 是可选的**

**mutable：**

**默认情况下，Lambda 的 operator() 是 const 的，即不能修改按值捕获的变量。如果加上 mutable，则可以修改：**

**int x = 0;**

**auto lambda = [x]() mutable { x++; }; // 允许修改 x（但修改的是副本，不影响外部的 x）**

**如果没有 mutable，则 () 可以省略：**

**auto lambda = [] { return 42; }; // 无参数、无 mutable、无返回类型声明**

**如果有 mutable，则 () 必须保留（即使无参数）：**

**auto lambda = []() mutable { return 42; }; // 正确**

**// auto lambda = [] mutable { ... };    // 错误！必须有 ()**

**-> return-type：**

**用于显式指定 Lambda 的返回类型（通常可自动推导，但某些情况需要手动声明）：**

**auto lambda = [](int a, int b) -> int { return a + b; };**

**如果省略 -> return-type，编译器会自动推导返回类型：**

**auto lambda = [](int a, int b) { return a + b; }; // 返回类型自动推导为 int**

**如果 Lambda 包含多条返回语句且类型不一致，必须显式指定返回类型：**

**auto lambda = [](int x) -> double {**

  **if (x > 0) return 3.14; // 返回 double**

  **else return 0;      // 返回 int，需统一类型**

**};**

**Lambda 形式   是否合法    说明**

**[] { ... }**  **✅ 合法 无参数、无 mutable、无返回类型声明（() 可省略）。**

**[]() { ... }** **✅ 合法 无参数，但显式写出 ()。**

**[]() mutable { ... }** **✅ 合法 无参数，但有 mutable，必须保留 ()。**

**[] mutable { ... }**  **❌ 错误 缺少 ()，即使无参数，mutable 也必须跟在 () 后。**

**[]-> int { ... }****❌ 错误 缺少 ()，即使无参数，有返回值类型，也必须有（）**

 

**[](int x) -> int { ... }**   **✅ 合法 显式指定参数和返回类型。**

**[](auto x) { ... }**   **✅ 合法 C++14 起支持泛型 Lambda（参数类型自动推导）。**

 

**在Lambda表达式内可以访问当前作用域的变量，这是Lambda表达式的闭包（Closure）行为。**

**传递的是副本**

 **与JavaScript闭包不同，C++变量传递有传值和传引用的区别。可以通过前面的[]来指定：**

**[]   // 沒有定义任何变量。使用未定义变量会引发错误。**

**[x, &y] // x以传值方式传入（默认），y以引用方式传入。**

**[&]   // 任何被使用到的外部变量都隐式地以引用方式加以引用。**

**[=]   // 任何被使用到的外部变量都隐式地以传值方式加以引用。**

**[&, x] // x显式地以传值方式加以引用。其余变量以引用方式加以引用。**

**[=, &z] // z显式地以引用方式加以引用。其余变量以传值方式加以引用。**

**另外有一点需要注意。对于[=]或[&]的形式，lambda 表达式可以直接使用 this 指针。但是，对于[]的形式，如果要使用 this 指针，必须显式传入. [this]() { this->someFunc(); }();**

**Lambda表达式无法修改通过复制形式捕捉的变量，因为函数调用运算符的重载方法是const属性的。有时候，你想改动传值方式捕获的值，那么就要使用mutable，**

 

 

| **捕获方式**             | **语法**                   | **能否修改捕获的变量**     | **影响外部变量** |
| ------------------------ | -------------------------- | -------------------------- | ---------------- |
| **值捕获 [x]**           | **默认**                   | **❌ 不能（const）**        | **❌ 不影响**     |
| **值捕获 [x] + mutable** | **[x]()  mutable { ... }** | **✅ 能（修改副本）**       | **❌ 不影响**     |
| **引用捕获 [&x]**        | **[&x]  { ... }**          | **✅ 能（直接修改原变量）** | **✅ 影响**       |

 

**[this]: 通过引用捕获当前对象（对象本身） [\*this]: 通过传值捕获当前对象（对象拷贝，且只是一个地址值）** 

 

 

### 如何截止？

**Windows系统下键盘输入时，可以在输入尾部，新行开始时，按下crtl+z键。在输入会和模拟输入结束**

**While(cin>>str)，再按下回车键，模拟输入结束**

**Hello hello**

**^Z**

1. **cin 的缓冲机制：**
   - **cin 是行缓冲的，所以按 Enter 后才会处理输入。**
   - **Ctrl + Z 必须在新行提交后才能生效。**

  **string str;**

  **while (getline(cin, str)) {**

​    **if (str.empty()) break; \*//\* \*如果输入空行，也可以退出\***

​    **cout << "Read: " << str << endl;**

  **}**

 

## 文件和流

### 流

流: C++中把数据之间的传输操作称为流， 一个字节序列, 如果流向程序（内存）, 从流中获取数据，则称这个流为输入流; 如果流出程序（内存）, 向流中添加数据的操作，则称为输出流.

 C++ 的 I/O 发生在流中，流是字节序列。如果字节流是从设备（如键盘、磁盘驱动器、网络连接等）流向内存，这叫做**输入操作**。如果字节流是从内存流向设备（如显示屏、打印机、磁盘驱动器、网络连接等），这叫做**输出操作**。

流既可以表示数据从内存传送到某个载体或设备中，即输出流，也可以表示数据从某个载体或设备传送到内存缓冲区变量中，即输入流。

流是一个抽象的概念, 当实际进行I/O操作时,必须将流和一种具体的物理设备联结起来

流类库: C++将输入输出有关的操作定义为一个类体系, 并将其放在一个系统库内, 以备用户调用, 该类体系叫做流类, 提供流类实现的系统
 被称为流类库

流类库的基本结构: 一个利用继承组织类层层次的典范. C++的流类库由几个进行I/O操作的基础类和几个支持特定源和目标的I/O操作的类组
 成.

C++流涉及以下概念：

标准I/O流：内存与标准输入输出设备之间信息的传递；

文件I/O流：内存与外部文件之间信息的传递；

字符串I/O流：内存变量与表示字符串流的字符数组之间信息的传递

流类库的基本层次:

 

ios类是istream和ostream的虚基类, 提供对流进行格式化I/O的操作和错误处理的成员函数.
 istream提供对流进行提取的操作
 ostream提供对流进行插入的操作
 iostream通过将类istream和ostream组合在一起来支持对一个流进行双向操作, 没有提供其他新函数

C++预定义的流:
 cin(istream类对象):与标准输入设备相关联
 cout(ostream类对象):与标准输出设备相关联
 cerr(ostream类对象):与标准错误输出设备相关联(非缓存方式)
 clog(ostream类对象):与标准错误输出设备相关联(缓冲方式)

操作系统默认标准输入输出设备:
 标准输出设备:显示终端
 标准输入设备:键盘
 任何情况下:
 标准错误输出设备:显示终端

**I/O 库头文件**

下列的头文件在 C++ 编程中很重要。

| **头文件**                                                  | **函数和描述**                                               |
| ----------------------------------------------------------- | ------------------------------------------------------------ |
| [](https://www.runoob.com/cplusplus/cpp-libs-iostream.html) | 该文件定义了 **cin****、cout、cerr** 和 **clog** 对象，分别对应于标准输入流、标准输出流、非缓冲标准错误流和缓冲标准错误流。 |
| [](https://www.runoob.com/cplusplus/cpp-libs-iomanip.html)  | 该文件通过所谓的参数化的流操纵器（比如 **setw** 和 **setprecision**），来声明对执行标准化 I/O 有用的服务。 |
| [](https://www.runoob.com/cplusplus/cpp-libs-fstream.html)  | 该文件为用户控制的文件处理声明服务。我们将在文件和流的相关章节讨论它的细节。 |

#### Iostream

是流对象！

**标准输出流（cout）**

预定义的对象 **cout** 是 **iostream** 类的一个实例。cout 对象"连接"到标准输出设备，通常是显示屏。**cout** 是与流插入运算符 << 结合使用的，

**标准输入流（cin）**

预定义的对象 **cin** 是 **iostream** 类的一个实例。cin 对象附属到标准输入设备，通常是键盘。**cin** 是与流提取运算符 >> 结合使用的，流提取运算符 >> 在一个语句中可以多次使用，如果要求输入多个数据，可以使用如下语句：

cin >> name >> age;

这相当于下面两个语句：

cin >> name;

cin >> age;

 

**标准错误流（cerr）**

预定义的对象 **cerr** 是 **iostream** 类的一个实例。cerr 对象附属到标准输出设备，通常也是显示屏，但是 **cerr** 对象是非缓冲的，且每个流插入到 cerr 都会立即输出。

**标准日志流（clog）**

预定义的对象 **clog** 是 **iostream** 类的一个实例。clog 对象附属到标准输出设备，通常也是显示屏，但是 **clog** 对象是缓冲的。这意味着每个流插入到 clog 都会先存储在缓冲区，直到缓冲填满或者缓冲区刷新时才会输出。

<iostream>库是 C++ 标准库中用于输入输出操作的头文件。

<iostream> 定义了几个常用的流类和操作符，允许程序与标准输入输出设备（如键盘和屏幕）进行交互。

以下是<iostream>库的详细使用说明，包括其主要类和常见用法示例。

**主要类**

- std::istream：用于输入操作的抽象基类。
- std::ostream：用于输出操作的抽象基类。
- std::iostream：继承自std::istream和std::ostream，用于同时进行输入和输出操作。
- std::cin：标准输入流对象，通常与键盘关联。
- std::cout：标准输出流对象，通常与屏幕关联。
- std::cerr：标准错误输出流对象，不带缓冲，通常与屏幕关联。
- std::clog：标准日志流对象，带缓冲，通常与屏幕关联。

**常用操作符**

- \>>：输入（插入）操作符，从输入流读取数据。
- <<：输出（提取）操作符，将数据写入输出流。

  // 设置输出精度
   std::cout << std::setprecision(3) << pi << std::endl;

   // 设置输出宽度和对齐方式
   std::cout << std::setw(10) << std::left << pi << std::endl;
   std::cout << std::setw(10) << std::right << pi << std::endl;

  // 检查输入操作是否成功
   if (std::cin.fail()) 

使用std::getline函数可以读取包含空格的整行输入。

#### Iomanip

 Input/Output Manipulators 的缩写，它提供了一组操作符

使用<iomanip>库可以对输出进行格式化，例如设置宽度、精度和对齐方式。

iomanip 中定义的操作符：

| **操作符**            | **描述**                 | **输入** | **输出** |
| --------------------- | ------------------------ | -------- | -------- |
| resetiosflags(long f) | 关闭被指定为f的标志      | √        | √        |
| setbase(int base)     | 设置数值的基本数为base   |          | √        |
| setfill(int ch)       | 设置填充字符为ch         |          | √        |
| setiosflags(long f)   | 启用指定为f的标志        | √        | √        |
| setprecision(int p)   | 设置数值的精度(四舍五入) |          | √        |
| setw(int w)           | 设置域宽度为w            |          | √        |

**5. 设置和重置格式标志**

setiosflags 和 resetiosflags 可以设置或重置流的格式标志。

#### <sstream>

在 C++ 编程中，处理字符串和数字之间的转换是一项常见的任务。

sstream 是 C++ 标准库中的一个组件，它提供了一种方便的方式来处理字符串流（可以像处理流一样处理字符串）。

<sstream> 允许你将字符串当作输入/输出流来使用，这使得从字符串中读取数据或将数据写入字符串变得非常简单。

\#include <iostream>

\#include <sstream>

 

int main() {

  std::string data = "30 40.5";

  std::stringstream ss(data);

 

  int i;

  double d;

 

  // 从stringstream读取数据

  ss >> i >> d;

 

  std::cout << "Read Integer: " << i << ", Double: " << d << std::endl;

 

  // 向stringstream写入数据

  ss.str(""); // 清空stringstream

  ss << "New data: " << 50 << " " << 60.7;

 

  std::string newData = ss.str();

  std::cout << "New data string: " << newData << std::endl;

 

  return 0;

}


**你可以用 "\n" 代替以上代码里的 endl。**

### 文件

支持文件的流类:

为了支持在程序这对文件进行操作,C++流类库在流类库基本类层次结构继承上, 又派生出了五个类

(fstreambase, ifstream, ofstream, fstream, filebuf )

fstreambase是文件流的共同基类, 程序中不使用该类进行文件操作, 派生自ios类
 使用ifstream, ofstream, fstream 进行文件操作
 ifstream从istream继承了读操作, 仅用于读文件, 派生自istream和fstreambse
 ofstream从ostrea,继承了写操作, 仅用于写文件, 派生自ostream和fstreambse
 fstream类用于对文件进行读写操作, 派生自iostream和fstreambse
 filebuf派生自streambuf类, 负责管理文件操作的缓冲区

 ![img](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAgYAAAFtCAYAAAB85KKkAAAAAXNSR0IArs4c6QAAAAlwSFlzAAASdAAAEnQB3mYfeAAAABl0RVh0U29mdHdhcmUATWljcm9zb2Z0IE9mZmljZX/tNXEAAJluSURBVHhe7b0HYGPXdef9R++FBEiw996G03sfjaaoWMVqtmxZLvHntM0m32ZTN8mXbHY3PfZmY2fdZMe27MiWbHWNNJrRSNN7J4cc9t5JkOj4zgNIDgkQJMgBQRA8N6GdvHnv3XN/5+K+8+6793+kXirt7e0QiURISUnBRBkdHYVUKoVcLp88xv8HE2ACTIAJMAEmEN8EpKGa5/F44rvl3DomwASYABNgAkwgiEDIwECr1TIuJsAEmAATYAJMYIURCBkYDAwMQKFQQKVSrTAk3FwmwASYABNgAiuXQMjAQKPRQCwW+8g0dX6CV+vOARL6f9xAftoO5MsH8G7Dlclj1dn7oXHdwcet9f5jHjG2FRzGUP9pXOnp8h+DGg8WPoDa9vdRPzQCCLeXmPFw/macangL3XaXrz6ZKhuHs8rw7p23MCp80aA/vaEcuy1J+GXth/CK/HakJW/Eap0Xb9SdmbSjOGM3MiSdeL/xxuSxdbkHIRm7jtMdTeO2SbGr8BC6ez7G9f5evx0iLQ4W7MX11nfRNDLmPya14NG89Th+9030O/yfVpTqfBzIzMdbte/C7vXblphQhe1mA1678xHdx29bVsoWlKtteKv+wqQd5Vl7keRtwYfNtyePbcw7BLf1Ms51tvqPeeXYW3gQzV3HUEPBmc8OsQGHC3bhYtPbaBuz++wQK9LwcE41jta9iSGqT7BDrSvC/rQsvF57BD6SdCzZtAYbE5T41Z1P/Peic/NSt6NAOYR3716etGMV+U/vqsNHrXWT/tuafwjWwbO41N057j8V9hfux532D8h/w+P+SyT/bcPpxrfQZXP6bJMqs/BQdjneq3sL1nHbdPoy7Emx4Fe1R+EZZ5SatAFrDSK8fuf0pB1F6buQKe0m/12fPLY29wDktps42d44bpsEOwoOoa/vJK719ozbpsWBwr242foeGkdGx/2XjEfzN+Ij8l+fXTAEkKtzcSizEG+T/2zj/kswVmFHkpH8d3zSf5mWzajQOMl/9/p9WeZeJKOV/Hdrmv88o1dwtqNl0n97Cg6grecj3OrvH+9bBhwq3IXLze+gddTms0MkT6W+tZb89wYGXWQI/a9KU4gH07PxBvnPR5L8Z05cjc2JavLfx5P+S6V+/+mCjb77cGEC90NgprE9j8b296aM7atzHoTaWTtlbJdge8FBDPafmTa27xfG9rb3cXf43tj+SMFmnLwbOLaX0tj+9uTYbhgf218LGts9NLafnTa2p4s78UHTlLE9j8b20YCxnWzr7v1kytiuo7F9D67R2N5spbFdGH9k42N7fcDYnkFj+52pY/sqGtv1YYzt+2D2NuFYc82kvZvyD8M1cmnK2K6gsf1BGtuPTxnbjTS278QFGtvbp4ztj+Suxgd33ggY2zNpbH9/yti+lsZ2RfDYrhic9mwuynyAnlml8+omIQODqXfJoAH8K/SAmShisZSeYV7kJG+aPCYRy4h3HsrT761NkNIxb2IaNuUJI7C/yCRy5Bqeg2fykIiOSZFW+aIwNo4XMeQSCT67+iuTR0QiCWRiEb68rujeWSKyg5z8FVP1NDvEKEG+ZdvkMcEOeLOxKmuqbXJ4E1Kx1TtRq2CHDNmG56fZJifbnqr60j3bRGSbWILPr8mZbhst3vzKunvwxT7bvPiKeV0AoyIUpe4MsC0La7Lv2SYwKjQ+jV0BtmXqPi88K6Yxerb6K0G2vbg2b5ptUsG2hIoAbuS/pHsPlwn/labvnWab15SODbnT/Zfn8990bmm6LwT57zNk20Tx+0+ML60rDPZf4qqgvpVv2TqdmzcHlZnBfWtL/nTbcgyfDfLfpyu/GGTb52b0X0mwbeZ7/V5gJIbgvx1B/ls9pW/JxHIUJzyFHQGMsnSfm+I/EfVxKZ5Z9eUg/31hRv+VT2EZ1s928nz+P5hAKAKhxvbcoLE9d4axPT1obPePDZO/el8fTw1rbBeHGNtXB43tBSlzje3+5070x/YCFKfumj42mDMjPLbnhze2T/GfWHj+zbOEHGGsVuvkpwQhEFDSX2ARBsrpRQKpf5JhSqEHQuARiTL4XlLflMK0opzx2Ex2BB6TYEbbgmpQhGWbIlzbwmY0A7cgRooZGAVzC9c2Sdi2heO/8Gyb2X/Bfg7btmAiUfDfwvqWBDP0LWlk/TfP3zqfzgSCCERjbA93jJppvAgeG8Id28N77oRt232Mn0EjiCS88TNc28IbP+fX+UMGBkajcX534rOZABNgAkyACTCBZU8gZGAwMjICmUzmmzXgwgSYABNgAkyACawMAiEDA0HwSPjjwgSYABNgAkyACawcArPuSgjE4PK4aEGdhAOGldM/uKUxRIB/fzHkjDgzxeVx09gu5rE9jvzqGy9obcRCXu/npWNQ01WDTGM+dMpl+nnBbcXtgS4UmXLx8c2fQpWyD1nuJtQ4FdiaOr/tHHHUf7gpy4SA8PtLN+bBoAxexLhMmsBmxigB/9iet3zH9jC52kbb0eKUosCgxSsXfoEdVc+ho+V9yMxrUaI1hnmX5XCaE7c6a1GYVAJF8I6AORswq/LhhI7BxF2EqPLe5rA5771oJ9zuOA23shBlxsSw63C77RhzDOF07cs41b0NKQ4r5PY2/KLmFWgsh1GZaIVeoQn7fnwiE4g2Abfw+5vcAhnt2rm+5UTA4+zHqeaTKMp8EGZZ8E6gwLb4+tYyaGBN6ydo8+qxI6PCJ8syV7nWcgQNwzZUZO5EmlKKIXs/Xr7wM2wpegjCG3VP3zn8vOZD7FNmY1Shglq2TF96ZwDhcvu1WxZSQgYGwgAUOAjFypqDjoHbGNCY5xUYtPWcwav116BW6HHu5v/G+c6bSDbkozRlAzY7m0jAyYrnyvaCd4gvpBvxNdEgECu/v2i0leu4PwJimRG5+mQcv/1z7Cx6HCb57MFBJPtWT881jGmLkamc//75uVrdP3ADxwYTsYsCg9BFCHFEuFj3Ck4MOFCqsONmbxN6PTU43dWDBK0G/+f4H5AQ2gCyGsuwhoKG1vYTGHFuxIPzFAKay96l/Pf78WlYOgZL2bjAuu+0fYCaES8O5WRN/lNn9xn8rP4SkhLK8ETRNnq4u0mB6zip+NWjx+nE06tfRLZlO36T/ho7T9G3NDmy9fkwGEqhEVvRbnfic9V7OCiIJUezLUyACdwHARFSSVxtB4mKnax/DztIsVQvCecdO/wqPR47ztx9Hdd7emGVJeJra55EPSmP/tXRf4bBshMHSg6TymgBfnX5O7BrKlCmtOO1php8ccNXYUIvfnbtFfR5DXii7HFYFCLcajtByoF1kOvS8dmSA7jd8kuc7e6BUpkEDUagNKzFptT1ODtwFj+//j30u5PxuapD+OjqSxgxbMAjaYn4t7O/wANrX4Cn5wS+efZlaC07UFL0AA6mF1PDyrGWxNrO1v4K0hIlOns7kZu6CmNj7XCoqvBAHAUF4Xtx5jOXnY5BCin4uW6965OgTc/JxcjgDXzr8js4WPUUmlrewI9vKfHZvHQcabiM/eVP4XbjMfTah6B123Ci4SM4pSl4tvpLaO44R51iHSk4uvCDs/+IK3092JqUdL88+XomsMgE/EuJbre+jyNNJM0s/IJJ/7qC5LYN7rt+2VrhmFuEzSQXOzp0Hpd7SNLa90xQYE/BA2jsOIa6YZK0Fm4lScCh/K041/jOpKS1RJmOw9mVeL/ubb+kNb2AaXTF2JuSSvLVH/rVG+k/LKa1WGOU4K0JSXKyoyBtO7JlfX5J63HbqnMegNJeg1MTktZekksn2/oHTuO6IGntkyRX44H8PaghuW2fpLVgm9SMw3kbcbLh7UlJa0Eu/WBWMUnqkqS1YAjZJkjq7khKJGnYcUlyOp6WvAFVGjfevnveL1FLthVn7EKquB0fNpEkuY8RsI7kfkFy6ecmJa2l2EmS1h0kl357UtJahwMkW3uVpqUnJK0ht+Dh3LU4Xv8WBp3+SXilJg/703Px9p334Zgil77FpMXrdSRJLrSJbMsiue1i1SjeEyTJxxmVZ+1BgqcJJ1ruTNq2kRg5hi/iYneHn5GX/Eeyw02dx3FncGhcLt2IQwXbcL7pHXSO+SXJ6YM5Pl3xJJJplsCcuAZVY9RXak/g4ZIdQYJg99NZ2zpO4mK/FY/QQ/zjuyfQ63IilVRMd2Suh5qUZ1eTaqoAv9Jswe9/+I94bvN/pVneFLjcw3j92s+hJUXdEnc9vnv++/itdY9Tn7mGHUWHcPH2j/CL5nyU2JqIN6AbuQ6zMRf1TedRWJSD2r567C75Ai7Qea/czUIxCdBdH+gGMnNhtXaTtLANVQmVWJuyGsq0tVRnss/ZrT2XcbzlBpIpYPpKwT5cbr+LVWnl8I7V4euXXkeHnT43xM+XhPtxbeiX5FjVMdCqklFqLoRtfKnlHcrjkJW2F+uSi7FO48FfXDpFI0A1KhIMeOncN7Am/zkavMy02PD7uDVAHSY1GR/X/Bg/v/E+Hqx+EQr3CFJIK39g6A7cFBjM/TXuvnjzxUzgPgn4H0K5lk14jgZ938OGDilklNvEm4HsJJIpHz+mkmvhob5fnu7PQSL8g0auQZbmUWycSKtOu4y0MhXMJU/RN9fxr8y0klkrVeCx8nvytmKSeVZLScK5Mm3SfikpmCpJk/w5bcFknXKpGjKRG5YEkrket0NJtom8acizjD+46A5qss1tOIhVGePfQWlFvEamRprmcTgDbDtc8jTc46aJSG1VI5XjiYrn6FOn3xQxKcmpSUL9uarMe7ZJVVCQJPlzenpTHLdDsE0qykFa4tpptsFrQVHKPUZqYpSrewhrs6bbllz0xD1GJHmulSnxcNmzkxLAE7Z9utIyaZuEbFPRm/pzVTmTtsnINrlgGwU0U/0n8WYhy7zhnv9kWniNSShNm25bluYRbAj0X/EU/5FPdePrCpy2dtym3AWrM3ZGfEbUYl4NU9t5/MuFl/Cpys/DIqVPB9JkpOmSoaVF6qlqva/Nqfos5Jmr8CDlBlGC2DtbcbTtNIrIf23uMdjpqEyqwSZLFo7feQdNXXeQm+ygKf90rJVnQDpyByZTGZyOGxhzeqg/70C5qRCGrLV4qeMWNlrSoR+mkVukQIYuxTeGa+g5ka6zQJWQh3RNAh0ZxdE7RzAiz0GSqx0/OfMLnBwYw+POvbDTt/h8Cjya+uuQlnJPcvg+f6jL+vKQMwbCwsP7+UaxmFQoZQKttPRnfTSqU9DT3ub7v3uGm2nA0cPuGkFJznOk8d+Ll85+C2/Sj3hTxnbINBRV0o/0asPHFN1no5O+hWWaK2GWyyBVJIW1mGUx28X3ZgLhEpDTQCr8TS9yBH3Wpfwf6sCzJAaamp1eZBJjUNUGytkRWBJUwa9UCargXRLCQ3ihtgXWKaNZjcBiDNM2+fg4ce96BY0dwdxUAZ/DFcQt6KwZGYVr20yMAjPXyn0BXoBnEHiWIkz/2cbacIRmVoqyHkXuIqy4H3aO4lD172KX9Qa+c/7bkK35PVQbtRilhd06Ci5djj7YJYm+oM2gSqDH/0QRI1GRir0VX0ax0oUO6zDN4L6Dn9Y34H/u+y28fW4E9R4nPBT8eLxuX+AlrHcTi2T00Heim2YFhNI32okEVQG87iEMOf1BSMtgPZRjNBtmMNB47qVn2MQjTkFJ/Q7SrIqVkgN6caK/C8nqHNR0N6AspQIKClQT1cG+DPf3GG/nhQwM1OrAH3ZsNP1O+zG8efcMvD2jyE/4MnLS96G49yX87al/pSkqJ56ofAFimrb8qw++S9NEGyFW5iHHkIhEimI36PJQ134SDmkm/vPuz0E2dIOyUJ2jIHcd8mXUkakDyhay6TM20LAVTIAJMAEfAY9rEKfoM2pB9iMo0i/OA6+j6wP87+v0xp5WghTKMJus9AeS5elFePnK/0F31nY8ULCW1gP8Ctfa6vFy7Ul8unAzxLJUPFm8ET86/dewaFKwOvtBlGqLkIAz+M6576DPOoiB0TP4WN6NTskQxCNNEPaf3extgJAFVunuwL+d+zf0Ohx4dvVmWDx30XX72/gmfZZoctmQZ+tD30A/jjR/DE9fLxLWfQGrEpKQQy+BOd5RnKt7H6mpu/HiqkdQ0/AOznfXoCpjM+UDWg77MqLTweelY+DxepZ8S0sqrTH47d3/H9FxwaigjkhTkA+t+gpWDTRBp0mDkR7woOmqP9+XgQG7DVq1BSaFkmYJfkXTVzVINhbhydWfQ5Iw1WaqxAGRBz+7dQQ11DGfr0jnwCA6/Y5rWQCBWPj9LcBsvmQJCIgkamwqfJI+9YS3M2Ahfass9xn8mbkDoy4XzIYsWsjtf6sqyXwYv25cDYnSAi3NPG8t+SJ2lknpXZ/E8cZZlGU/hP+ctAaDbjmydGY6mobf2/n/opWCgjS6l5u2ltvpaSNkcRUJf3Sfw4UeaJUJWLVrNZoHmmHQZdGCSuGOxfijXb+PLrsLv7bmC74aHM4h/N6+/0ERkgMqlYGO2PHWle+jllIb55tW4Uurdvg+OZTTGhOR5B28d/NVZNM6j09pTUvgrcWp0k3P64WWeekY5JnyoKL8CUtZNEoTNDPou2Qa7+1SEOwzUEBgmDLpUZy+B9lpD0Avn36xiRbLfHXLvbS/S9k2rpsJzEZA+P0p6Ps6FyYwFwERTbsr57FgKo9E35TzHtslSKIdBDMVsy5j8nCKLnXGcwzqNAiP7IkilRmQbfQfkdG28tAyXmISY8qedk+lwoSsKV+55DI9UujvXvFiZ/HT2E11KAM2Z5SR1oPwF19FikJzHmS+wGn+JWRgIHzfCVxjoFNo519DjFwhp293PKTGiDPYjAUR0C7j39+CGswXRY1A/PctEWnYTA1DooZ2iSoSkYrlwp/XIQODsbExyOVymoYJXPqyRO3kapkAE1iWBM41HYMlaQsyA1f4UWtso3fxQWcPbUFcRfvh76DIUuYL4B1uB+RTFhhebfoQOvNW5Kj9M5Z17acB+vyXrwvx/dzZizcbLiKDZhIt6nT6lj19UV97zzn8ou48LfbzD4E2hw1bi59BdcK9qWQrrYY/1jNEe/HLcLX7LomhlfpW9jtoLZN8hin6y03vQ27cjFJ9bK7PWpadh41eEgIhAwMDrerkwgSYABO4HwK24cv4n8f/Pzy17dvIzJk+/SusOB8aasK5tnbsz8rH61d/gd30Fbq34ziuW2X4jS0vjq/IH8W3Pv6fMOd9EfszirApvQpn638Od8pnZwwMBKlbuLpwtPYonlv1OP7u3F/hyzv/BAVq1eQ37trOW5CrC7GH9r4L5d0br6B51EaBgb+1gm39g3dxoX0Y+zMz8BrZ5qBZ2ba2o7ht0+G3Nj/vC2C8Hisut11CP0ntvnr1NawqcqBLQ4EBaTWoacfU6uTCiG8TvB9/8LVMIBwCIQODYRJAEWYMFApWfAgHJJ/DBJhAAAHPCL515if47K5/QOrISXzQ6sae9LzJk642vk5iQJ+Q2JIT/359CC3DnbjUXYvt6QexUSVBZ18XchKT0d1zHunpB0gUyIEO25jv4W6mvfFG0/Q9512kdvePF9+i78/C9+0R2rp2HW83ZtC6DAleu/EqXqh6lrYm+6tP1uhJYOgqTqLDtxWukURxNustk7ZdrH8N79SfxB0r8KPr3WgVbOutw+asR7BR7kV7fw+yE8zo6jmFH106ir2lu/CZDV+hQMEJIe9A79A1/Oz6cZQc+iPoFvaZl7sTE1gyAiEDAwntPY1VHYMlo8UVM4EVTMDrsaF1qB0+ob+Ah53XNYy6oSFszt4CrSC967Xh9Uvfgin9YWiHrqNPnY/W+pfwP1or8JmSrbDQgrRVOY+ixFyOf799BVsySjHU20ULw8Ro7L+K9699DJtuJ343YR+uddZBQ+srHCS6ZPAO4YcXfoCzzSegGfDiOr28ZGXtxu7UQvQON2IIOjxI+9X1Sh1EZOjWVV9F8tgp3KS3/ImgwOvqx2V6yKdqdZDQ5wqx14F0tRanG4+gqPwAlNS2tfmPozipFD+9cxub0wvQJ9hGxxv7LuEdqlucuB+/nbAHTrcHVVn7sSejEG/UnqYV7oRGbsaDJY+Srso7tPd+BXcYbvqyJRAyMBDWFkwEBi2Ui+CNuxf90qIkBpabsgU58kEcbSLZ0/FjlZl7oHbV4fSE7KlHjE25+zE8eJ5kTwVhIYGRCnvydqOOJFkbRygU90mymnAgdz3ONR9BD203EfZDSlWZeDCjGB/cPYKxcUlWnb4E25PMeKv+BLzCdXQ8lVJlVuq8ePfuhUk7CkmSNU3chWMtJHs6btvq7H2Q2G7hXGeL/5hHSpKsD1BmrdOkhtg3Lherxb78HaTXfRQt1jG/bbIkHMpeg08a38MAKW75FObUudhHsqdH6j6gDTDCvYAEYzk2mwx4U5A9FVa8km0ZJMlaorLjSCPJno7bUZq+kzTCW3GilWRPx4+ty9kPl/UqvSm1+4955diRtw9t3R/jztCg3w6xAfvztuIKpQftoO02wjGxPBUHsirxUcO7GBaE0cg2NSnQ7U7JoDedDwUFWJ9tZlKgW2dUkjQsfZMdty2HJFnzFMP4oOnapB0V5D+d6y5Okkyon5EYG0nKdnToIq7SoOi3TYXd+btxlyRZG0hNbUJS90DuJpxvfg/dgv+oSBUZlIykBEfJf6MT/iNJ3e3JyXi7/iN4xv2XYl6DVTox3rl7btKO/NRtyJD2kGY6yf2OM6rO2geZ/TbOdjaP2ybBltwHSFL3LG7SPmV/39Jgb/5O1LR9iGbrPUndQ7nrcJL81+8gQ4iRXJ2NB9Lz8X79B5OSukZSoNtinu6/9KT1KNM48V7DpUk7iklxLQnt5L/aKf57AJ7R67jQRSJbPm4y7Mjfh/aek6gdHBiX+9WT/7bhKskYt4/6/SeSWSjfR7XPf0PCk5b+V6XJx57UTLxL/vNpBJL/TKTKuT5RTdxI0XPcfxaSdP0UqchFu7idg/Tw/AADgpsDAwPSzR9wSVGSugF2+x38quYk0lL34zOZFfiPkxfo/36YftOF+OaJv8I3znfi97d/DYliGy62fohj5P88Snv+cMWDOENbivtcImSk7sCGrB304O0nJeAcuLt+iWHdIygkgaU03Rr00ycKjakc60zJpFHif9NXk6iSw9aJozW/wC3qeJX6VDhtrfjRxe/BnP87k7hs1ruUb8WBp8q24sNbP4XTsBF7s5LwvetX4BACA6GrU4r2C81HybbrKCbZ3EfKHiAZ9jr0OUXIzdiNjZmbffcTxkix2I2zxKXFnoyH80z4p7MfoCqZ6p5QJ4y2o+ZRX0v3aRrb7/VxYWzPlg3iw+Z7Y3sVjQ2qgLF9M43tQ3ON7VITDtLYfqbpCMnSTx3bi2hsf39ybNePj+1vhjG2p9LYfrz5nqT1zGP7PhrbzwSN7TdpbG+dOrbnrMUn9PubPrbn0Nh+dMrYXkFjuz6MsX0XaS204OMpktbraWx3ThvbFTS276Gx/ZM5x/aDJEl+/G7g2J5OY/uxKWN7NY3tchrbzwSM7UM0to/7T5App/66l7Ql5lNCBgaDg4O+zwhCgJBkKMbhknEpVGEAUxihErtwWJUzKd+pVSZC4k2kKT7KeuUbNESkdmWCW70NOUmOcZskSCQFrETSda+YSAlJ22rMtM90e+4BOMYlWcViJUxKDYljHJ6UQpVKNDCSQuHhIsOkloKCtqNoaTA+XDK+HUZ4OCoSSAo1FYc14zKtVLOOtjiKPAZYjOMyrWSbkWxLU+1A/qRMqwQmUr4yZD+AVZO2yck2HXblHaK3JL/4hViiIl0EFfYXHvZrxlORSbUw0CKmw8X3FkIpaVuMRuLBYSVNawo86HIN7cGVIRkGyjw2MbDqyTavTov0RP8DQ/BwgioRFuUuFNP+YP/oI4VJZYSWOpp9fLARiRXESIs9+Yd9wkxCkdDe5US5AgfItgmpDrlUB72M9gAXC3uF/Xbc8x998x23TfCflPyXqC+75z865tZuRVaA/0zyvSh3T9jm99+2XNJ1n7RNCTP5b1+Q/+Q4VKSfwX/jU7g+/xnJf2k4TG+YE7bpiIeY/JdMD8mJviX4L0O9HXnJEzK71LfIf0YKAqum+U+PnaQ575zsW+Q/pQoPCP4bhzSr/0rGt2ON+08O2gZLi96m+g86HVITgv1XlDJu24T/SJxl0n8k32pSabE7T/Cf3xC//5Q+/93rWzrqW4L/xhfFCcEpqXsuRZEqLHhi1RfnrLrZKqK964+hUD+eFp1U8Nz0oBWRXO5Xd/3N5PWnb/0CbzbfwPqCZ7ArrRTfOvpHJJO8GkkKGz3cP0Rp1oNIl7hpH/sATeV3kZxzHf0uyvBwejllw8uALqkK5Un3FgvaaMHiocqv4lM56fj+5bewLpGS6nzyP5Bq2Y3P5JVM1iul304aBfPCjMAH1zw0c0ECO5pWWOqaKMGa/7SPb72CdymA31z4GWxNKcQ3jnwbcgrIEqWjOFJzHJU0SzBRBO9JaaZjcKwLrYMOuMUqqKSC7l7slyRDCY2f9/q4b2wQ0dhOqoCTvz8aB8QBY7vw+3OFObbvCBrbKS/G1LGBlCiNMvmCxnZh/MScYzuNn2qjb2y3BYwNkR3bk2CcMrYbyDZPVMb28Rw/IZ7NavLffEvIwEBHg93EjIFCbkAG/QUWtdwYcEhND+GAQ6QnHnQWKV8FFiXpYgeW1Cl7YSf+LZ30wwNLRtBAqaGpx8DVyiqaXgy2Legs6Qy2zbBXN22GlccZM9oWyE0DrSLQUSoKoqbbppGl+NS+phaV9p5O/cTxlBkZBcqq0gyGTBeW/7RBm4dVFERNv1RNtgX7L9i2mf03g20zPOiC/Tdz3wr0n3om/83Qt9J0wSvHw/WfZgb/6YP8pwzTf8H9Po1yBgT18Rn8N98fe7TOzzSXBlQlorEkOLPf2qJnsS5rC16uo1kqeg+yu2gnAuVCkNEbuFSsgVJKszwiCp4KP0VbATowQkFBsTbRFzTZaWeAwu2bs5ssbhH1htEGfO/jH6NbuYn2ptNs3398Cb+59r9RYDmGLqsNybSLwU5BrYoeRMI9W+0OlI3eRj/lgliXuZrSTPnLptLnsS57M37RQAmM6P3RTgmCVD7bpJTnQE3XT6mY1hRIyT8KcT+JqtlRmJhJ+Rwky0JiPeTYTgFCwK8+wmN7cB9PD5KDpnGLx/ZpbpiRUVhj+/x+/SEDAzdFVkK+BOGPCxNgAkxgoQQcJM87QvK1QYVW9F9pu4DmMWFFoIg+G4zBZhumj0I2Ot86ORMmXNfRcwGv06zBf9/9m74HrlNY5DeRRcl3YxdN80tRnpKNt3svoiTRTLsSTuH3dvwXHD//p7iuy8dTlb9G83W0y5FmDre6LuFb576HLSWfR4K9Fn939QOo9RtQml6NJDm97dPCySutF9BqEx6QZJtrFEP2YSjI5hHKETCR1Mkr7Kwg/f2y8oexJtsfLbjt3bjQchJtdpolWSg0vo4JLCGBOXUMpJRRjQsTYAJMYGEEPEgkLYFkebAeypitgxbsnUJq3rO+Wwvrg1KTVlFmRysl0KHPQlNeSjaXfhXbtOXIVPvf6U2ksa+nT3oTZdjaBrUqHYUJ+Sjc9nv44OZPoTXtoNmGg9iU8i7+rf4WUmgW1G1vxQ9vvEFrX5Qoy3sKO1OEXRIlqEjbhH899QO0jQ1QYJCI0bFWvF17FnmU3lcoJZSdMCu1GmrRMH2CSp7caSCV0idKmn2aKj3soCDieN0JJCTtD0qAtDCGfBUTiC6BkE99vV7PuxKi6wuujQnEIQExDpQ/M2O7dLRY9o8P/q/xf/Pi4aqnJ88rSZq+uDInmVJMTyl7yoQH9r33cSEoWKPxawB7afHIjpLnKMWy/4LM9P34C/rz/5uZ1nB8ChatMHdwr4hpofHXtv9n4QzfQYOuBH/60N9O2vap6nttKEleP3mhhdJcPz7+iXfioIoyt/7uvol2xaFLuUlxTyBkYOCgqT9hyyLPGMR9H+AGMoEYIDDfSffp50vE9xIDiGgtQKiBTVi0GxgUTG/8THaEtm2+VscAaDaBCcxJIGRgMCFs5BHyYtPmXOkMi4fmvDufEJME3LR6G7R/ex45VmKyHcvGKPoWLnwTl02R+F02trOhTCCGCbhoLBO0KDhAi6yTZl9AQCt5zzVeRFHWBhgF0ZIpZWioDpeGbNiRUR5Zi/hui0rA6xrCmZabqM7ZQN8/p/+cOnuv4q5TQ99k76nTLaoxK+TmzV2XMUBb9SpNgTs37Pjk7lkUZmylNOA8tK2Q7sDNjBCBMWsLLvf1YX1mVdBLTk3baTjUBagwxk8a5QhhC+s2swYGnb21cCvMFBQEn6ZSqFHb/jFKUsqQPPExL6wq+aSlJNDYdQsK2r4XGBQINmkVSlwhsZkqCgw4DUxkvOR1D5EY1CBW5ZIGQ1CRwz3WQsJb9TiYMV3eNzK1812YQPwSqOmqgzlp9YwznzqJC281X6DA4IH4BbCILQsdGNBswZ3BPpRkb5+xepkiFRtMRlxovYUD2YH7lhfRYr71ggl4XANopEQx60kdcaai0RaiXHMBFzpbsc0yc571BVe+Qi9s6q6hbXB50AfMuPlxiLCZFC1/cuMkxigw4DymK7STcLPnTcBmbcaASINK7cxiX6mWjTC3/Qi3R8ZI+4J/WfMFHDIw6Oy7A4kmHSZZ6C/RxWlVuHDtBKxZpdDwTOh82Uf9/MauGuiN+VDPIk1RlVaCn9efwSbLY5wV7j49JOQPaBwZxerczJB3kiozkSp7Hxe7urCFJKO5MAEmMDeB2131yKSdKqGHMinJUlvos+l5FJdsm/uGfMY0AjMHBpQs5c5AD0pzds6KS67MoRzrx3CGdOJ3W4KV75h17BDwOAfQRDr961JmnwnQGVbBKDqLKwPDWGMMVkuMnRbFviXNPbeh0edAN8cqzw30jfTlhpPYnPwoL6KKfbeyhUtMYMzahAGSwarUzD4+5aRuwrH2/0CbYwvSSLSKS/gEZgwMuvpqIFZnkC743DDXpa8i2dDz8FBgMPfZ4RvGZ0aWgDClrTfmQROGk9aTNvyHrecpMNgVWSNW0t1otqCBEoWtzsuas9U6ygFh8lzCreExlOp42nNOYHzCCibgRU13AzJpbcGcQxkln6syGClRVw3Scu/lyljB8MJuenBgQGsLaijjYFnOzGsLAu+sN1bC6L1Eb5iDqDYG51MI2xI+cdEIeBwDaBDWFqSGt24gzbIeopaXUT+6BXnq8QT2i2ZdfN64sfsWNIY8UPLIMIqUfJOHD5vOoLR89lm6MG7GpzCBuCVgHWmk2QI1rS0IbzazKms9Ll49geHskjB/i3GLbl4NCwoMegYboNRm0mxBuLvcJTSo5eDD9ssUGOyYV+V8cnQItA00wpRQEP46EEoSU20241LHDeTlVUfHyHiqhTIJttvdqLCEXlsQ2NyMZFpd3f4LNNu3IFMxNUNPPIHhtjCB+yHgRuNAJ7LMZXPPFoxXI1FkIV/txcXuDuywBCd/ux9r4vnaoMDAaCjAGkqFPJ+SlrITj5qmZzqbz/V87uISsNAPKZ3U4OZTSrMPI4syynFZAAFS11tL2h+ULTn8IjHgiapn4Z2i4Bf+xXwmE1gJBMQoSF0L+Qzb52dr/faSp2CbyLG+EjBFoI1BgYF0ng8Qvw0iaCi9MpfYJCBbiE9J6VIjm0hCG5vtilmrRFIsRK9ILmXeMetTNiwGCIjmHRQIRotp/JttJ1YMNCzmTJg1V4KQcnlqroS6njqk6LOgkc/v7TPmWs0GjRNw+xby5CbmklzvfF5vGeBCCfSPdWLI5kV2Ak9rLpQhX8cEAgm4PKOo7+1CUVIOw4kAgZCBwejoKIR8CVMDA1+OdI8nAtXyLWKDgBfDlDOeZ9mi5w2Hywarw5/BjwsTYAKRIeD1ujBEYxmXyBAIGRgYjcagGsQ0vcw6RpEBHyt3kXByrKi6QkS8xSIODKIKnStbAQRE4LEscm4OGRiMjIxAJpP5Zg24MAEmwASYABNgAiuDQMjAQCQSQfjjwgSYABNgAkyACawcAiEDA41Gs3IocEuZABNgAkyACTABH4GQgcHAwIDvM4JKxRKt3FeYABNgAkyACawUAiEDA61WS/s/eQvbSukI3E4mwASYABNgArPOGHhoW2LgGgOXxwWvl1dUx1PX8fk0nhoU423xeD1w8/7QGPcSm7f8CHhpK717+ZkdoxaHnDEYGxuDXC6f9ikh3ZAGJe1U4BIvBMTIMKaRdC8vMo2WR3WKBEjFHIpFizfXszIISMRKZBpZNCxS3g4ZGBgMwZkSk7XJkaqX7xMTBMRI0bFPo+kKjVxPyqHRrJHrYgLxT0AsktNYZo7/hkaphSEDg+HhYd+MwVQdg7t9DbBo06FmSeQouWexq3GjrqcZWQnZJInMswaLTVu4/8BYN6lNeunthgOyaPDmOlYGAZdnDI193cg3Z62MBi9yK0MGBhKJJGiNweDYIBJVqYtsEt8+egS89KAapM8JwtQ2BwbR4G53jZJ0K39KiAZrrmPlEPB6negfG1o5DV7kloYMDIRtioGLDyWUEpY1jxbZI1G+veBTLtEjIEgiS1gSOXrAuaYVQoAkkXksi5ivQwYGg4ODrGMQMcx8IybABJgAE2ACy4NAyMBAp9OxJPLy8CFbyQSYABNgAkwgYgRCBgZut9sncMQiRxFjzTdiAkyACTABJhDzBObUMZBKQ54S841jA5kAE2ACTIAJMIH5EZiXjsH8bs1nMwEmwASYABNgAsuNwLx0DFgSebm5d257WRJ5bkaRPIMlkSNJk+/FBCYIsCRyJPvCrDoGgesLLDoLFPxpIZL8l/heYqTqLSTRyxoG0XKEoHzItKNFm+tZKQTEIgWNZUkrpbmL3s5ZdQwCa0/Ts7jRonskqhWIkW5gn0YTuZArQaeIZo1cFxOIfwISsQIZBkv8NzRKLZyXjkHTQDOSNClQcSKlKLlnsatxo6GvjYKDDJZEXmzU4/cfsvVixOFFmp513aOEnKtZAQTcJIncPNCHnMT0FdDaxW/ivHQM+qx9MCiSODBYfL9EqQYvesinKfp0yHiCOyrMR50j6B/lwCAqsLmSFUPAQ5LI3dZ+Dgwi5PGQgYHL5YKQL2HqOgO/JDJ/IY0Q+5i4jVTwaUxYsjKMEAuSyJx2eWU4m1sZRQIiWivF8u6RAh4yMLDZbD5JZNYxiBRqvg8TYAJMgAkwgdgnwDoGse8jtpAJMAEmwASYQNQIzKpjIKNFhkqlMmrGcEVMgAkwASbABJjA0hIIGRgInxCENQZcmAATYAJMgAkwgZVDIGRgwDMFK6cTcEuZABNgAkyACUwQCBkYDAwM+D4jqFSqSVpujxter5fpxREBl+DTOGpPrDeFJZFj3UNs3/IkwJLIkfTbrIsPA7cmmjQmyFkSOZL8l/heIiRpTZDyFtSo+UEt08Kjjlp1XBETWBEExCI5krWJK6Kt0WhkyMDA6XT61hhM3a6YacyIhk1cR9QISJCdwD6NGm6qSK800V80a+S6mED8E5CIlTSWpcV/Q6PUwnnpGLQNtiFRnQylLORlUTKbq4kMAQ9aBjpI+TCVEylFBuicdxm292PUAVh0CXOeyycwASYQHgG3x4b2oQFkGFPCu4DPmpXAvHQMOke6oJEncmAQN53Kg47hLpi1KRwYRMmnVscQeq1eDgyixJurWRkEPF4H2od7ODCIkLtDBgZDQ0OQy+XTdAykYilLIkcIfKzcxufTWDFmBdjBksgrwMncxCUgwJLIkYQeMjAQggLWMYgkar4XE2ACTIAJMIHYJzBrYMAJk2LfgWwhE2ACTIAJMIFIEggZGAwODgbpGESyYr4XE2ACTIAJMAEmEHsE5qVjEHvms0VMgAkwASbABJhAJAmEDAwcDodPw4DTLkcSN9+LCTABJsAEmEBsE5g1MBBMnxoY+CWRY7tBbN38CAg+5RI9Al6vB27+EUUPONe0Qgh4wWNZ5FwdMjDQ6/VBtRhVRsgk4sjVzndaYgIiJKiNELMkctT8oJCqYVBErTquiAmsCAIikYzGMsOKaGs0GjkvHYOcxOxo2MR1RI2ABHkm9mnUcFNFRlUS/UWzRq6LCcQ/AalYhXxTZvw3NEotnHW7YuD6gk5SyTOqEqHgREpRcs9iV0PKh0M9pHyYxMqHi416/P5WxyDGnIBZw283UULO1awAAm6PHV0jQ0jVJ62A1i5+E+elY9A21AalVM+BweL7JUo1UK4Eyn9hVJs5MIgS8WH7gE8SmQODKAHnalYEAY/XTmNZJwcGEfL2vHQMWBI5QtRj6DYsiRxdZ7AkcnR5c20rhQBLIkfS06xjEEmafC8mwASYABNgAsucwKzbFYVcCTKZbJk3kc1nAkyACTABJsAEwiUwa2AgJFLiwCBclHweE2ACTIAJMIHlT2BeOgbLv7ncAibABJgAE2ACTGA2ArMuPlQoFL5ESlyYABNgAkyACTCBlUEgZGAgBATCGoOpxUNyrqyIHF8dw00+5RI9AoIksoclkaMHnGtaIQRIEpnHsoj5OmRgIKwtEAVI5WoVWtrvzpLIEaO/5DcSQU8+FYuW3JAVY4BcqoRGvmKayw1lAlEhIBJJaSzTRKWulVDJvHQM8k15K4HJCmqjBIVJ7NNoOjxBZUECSyJHEznXtQIISMVqFCXlrICWRqeJIQMDo9EYZEGvtRc6pRHygE8M0TGVa4k8AQ+6R/qRqE6EhKcNIo93hjuOOUdgc3kpONBFpT6uhAmsBAIer4MURUeQpE1cCc1d9DaGDAxsNpsv5fLU7YpNA83IS9RArpq+9mDRreQKFomAB439zRTsJXBgsEiEA287aOv1SSJzYBAl4FzNiiDg9tjQ0N/GgUGEvB0yMHC5XBAHrCdgSeQIUY+h27AkcnSdwZLI0eXNta0UAiyJHElPhwwMdDqe6owkaL4XE2ACTIAJMIHlQIB1DJaDl9hGJsAEmAATYAJRIjAvHYMo2cTVMAEmwASYABNgAktEIGRgICw8DNQxWCIbuVomwASYABNgAkwgSgRCBgbDw8MQJJFVKt50HSVfcDVMgAkwASbABJacQMjAwGAwBM0YsCTykvsr4gYIPuUSPQJekkNmSeTo8eaaVgoB4XfFY1mkvB0yMBgbG/NpGEzVMVDJVJAEyCRHyhC+z1IQEEFNPmWXRo+9TCKHSsYZR6JHnGtaCQREkPjGMi6RIRAyMHC73UFJlIqSCiNTK98lRghIUGJhn0bTGYnqFFKajGaNXBcTiH8CUokGpRaWd4+Up1nHIFIk+T5MgAkwASbABOKAQMjAIA7axk1gAkyACTABJsAE5kmAA4N5AuPTmQATYAJMgAnEMwEODOLZu9w2JsAEmAATYALzJBAUGLhcI2i39gMiuhMtnpbL9NBLRegZG5w8plIYoRK50GcbmTymU5og8Y5iwD42fkwEo8oEl2sII06H/xitHDWpEjHq6MOYyz1+TAaz2oChsV44PP7V2iKJEmalBn2jvaCzfHZIpRokyOXoGe2Hd9w2hdwAncRLtg1N2qFWJEApcpBt1sljGqUZiYror1gdtfejdwojrTIRMq8N/fbRSdsMKjO87mEMOezjx8S0OM0Em6Mfo5TIys9NSowSMEyZ+exu/5YckVgBM6Xu7R/rAWXx9TGSSNTUTiXx6BP+33H/6ch/Ejo2cM9/ciPUYtc020L5z03+G57iv0Ty3xjZNjZpm+A/I/mvZ/7+o76lC+hbM/lPT31L5LFi0GGb7FsJ1LecM/Qtq70PNlo4O8EtWWuBIiAZ2Dx/I9NOH6Z2Djgm+jjg998I+W/CNjESyH8OxwCsLueC/NdL/vN52ff7I//JyH+jgf5zk/+GJ30q9C0p9a2Byb7l//25XcPkv/G+BepbdGx635LArEmBSiK+Hyx8LROYmYDHQc+TLrgWaWzXU38WuQPGBuH35xyE1Xnv92dSJWDa2CCSI0mlxwA9d5zjtoklKpjoOTH19yeTaWGUSdE95fcnPBMt9MyK5xIUGIxYm/BW7Qn/gEOjkzlxFdYa5Hjn7lnQuALhSZ2Tshk58kF82HRDeNb7jlVk7obaVY8z7Y3+Yx4xNuU+gOHB87je2+M/BhX25O1CXedxNA6PP7iliTiQswFnm4+g104PQuExqMzA/oxiHL37PsaEyIAGSJ2+GNuTzHir/mN/YEDHU8xrUEm5nt67e2HSjoK0bUgTd+N4y+3JYyWZ+7AjNforVtv7ruH95pv37MjYAZO3DR+33pk8tjbnAbitV3Gpu8N/zCvHjry9aO35GHWD4wGPWI/9eVtxpeV9dNgoyBICA3kKDmZV4qOG9zAsYCNGKm0+dqdk4N36Y/CRFPyXUIV1RiXevntm0n/ZKZuQJx/G0abr0/yndd3FqfaGcf+JsIFsGx2+iGs93eO2KbErfzcaOj9Cw/B4UChNIP9txDnyX8+4/yTKdDyYUYIPyX+j4/7T6oqxIzmJ/Hdi0n8W8t8qnQjv3j0/aUd+6lakS3txvPnW5LFVWXshc9TgXEfzuG0SbMndh76Bs7jV1zfet9TYk78TNW0fosU6/uCW6PFQ6eNIU8oj9huu7z6H0x1NU/y3D57RG7jY1TbOSIbt5L+OnpOoHaRgWvjNiHR4IG8brrZ+gI4xekj7/GfBwexVONHwLoZo/BKKUp2HPamZ0/yXmFCJDQlqvF1/etJ/WZZNKFCO4IPGa5N2lGXsgt7TiFNtd6f5b2z4Eq72dI3bpsDOvD1o6voIdyf8J9bgwZLHka2OfuAcMafwjWKWgMfZjw/r3qIxyv/S5x/bi2hs/2DK2F4yPrbfGxv8Y7uXxvaL08b2VBrbP5oytldn74PEdgvnO1vG+70UW/P2oafvNG4P0Auu7/enxb687bjRdhRtoxTAC0WWhIM5a3CSxs8Bp/9lS6HOwd60HByp/xAOwVw6bDSWY7NJT+PWSf8zkcYzs6kaj+dviFnmkTAsKDAwGsrwlXVlQff+inl10LGilG0BxwpRnRlwyJyNrfnTjxUkfCboXlnGF4OOPb864EI648uJ5cG2Ja0LOlaStjMSfO7rHvmp2yH8TS8lKE/fE3AsFxtyA85KfAZ7A87KMb4QZM+z1V8JOvbi2uIZ/FcddKwwZWuQ/6oC/ZeUgy0BMVVRwnNh+e+zM/pvhr6VtDbYf6k7Ao7lY01WcN8KPKvA+Px9+Wyui1dlHcCqQDuQh/U5068sTczC7kAvGz8fdPtnVoXpP9OqoGsLLFsCjhWhKiPgEPlvc4D/ihOD/TdXu/nfmcBCCIgVFjxb/eWgS59fXRB07MuJM40N64POKw0a2/OwNjvgNFMWAp8AecbPBd0rc9WXgo69sKYoePxMrFxI85ftNbzGYNm6jg1nAkyACTABJhB5AhwYRJ4p35EJMAEmwASYwLIlwIHBsnUdG84EmAATYAJMIPIEODCIPFO+IxNgAkyACTCBZUsgZGBgtY9AStsGFdJYjh08cLhdkFNimuDiwSBtWdQrdEucJMiLIdqyqFFoOQFVlH4mDrcNdpcHOsViJSXwkE+tdP+l7luzA3V7XHALWx4lwb9hp9sOG20ZXjxGUXI2V7MsCNhco3DTTjWNXLks7J3JyGH7MJRSNWQS3xa7uC4hn/rNA420HzsDFl3s7dds7DqLIWk20j138FrLMJ4vq8ZLl9/G0+s/D82ku5yo7a5HdXoVpEuaPtCDOz31lKyonLJ/xXKQFT/9fGisGx0jTlSkLNYWVQf1rbu+viXx6UzEUnHiZOMpFKZtxY1bLwGWw8hxXMGpMQ2eKry3i2GE9B6aB62oSg1eHR5LrWFb4oNAz0gHRp1yFCUFbptZePuE9OXiWcd2Yc9h5H6gd/vuIkOfj0TNvafMwq2P7StDPqnEIjG9aU+F6sVrV76DhNSHsSMpedZWCTnnp18bGQhe9xhqem+hbeA2Xr7zGnan5cPlVuA/rryEFrsR55vO00BXSYIU/hkEiTg2IjvBjoV0T7uzD2/d/Cmah6xYW/QstiSnhQQp7MSNvESNHb849z0oUvfgUPryycIoor4r9N/FLPfTtxbHV4B1rAM1/U242XoEvyKNkTKFDeq+M6RtcAIm805c6KzBKkuRTy5D+H1KFpnRYvLney8vAsLvMZzfZEPHCbx59ypcchNerP40tBIPXrn8XaRnPI5NpkTSa3Hg3Rvfwbst3fid3X+EdPkMI6vXipfPvARzziHstQTuYwzmNjhUg1drjqDLKcGTq15ArloxI1yJiMbxJX3JjJ7Pw36F9dC0pEmbBiOpD04tTreTplZkvkNerwctNAhdtivxYM5ayOiB6PG4IQ7xgHbRv0mn/puXpj5J5U94C5sp1hN57Wjsq8GYKAEbTUp84/Q/wkMiNiVpG7AntwwDo50YcZVRYBA9gItVk4dYvH7x2+hUVWN3jhxjfskiKh5SESOhkHE1Pzepfh25+Tpy8x5BvkrpY+chBSjxTL8X8qFIPN3lU/0X3BYF1CI3ukatNA3ookBr6rUeUgwTkY+nVkS2Ud3TZ2g85FOxX98qzouLGEkD+VIfF34HPs/RoPbxrV9ClbITq42kFEqDpZuCaMlMg43XDQ8NRFPDGxf91qTjv7WZUNrsPRQ4N8JCuh71tT/H3105A7MuB6sytlOQ4EXHaB8q6MKV4Is472px2DwvbCM38e0rR/DY6mcxMNRCCqbwjT9mbTo9d8YHdZGUNAt24XL7f5AyrPCd7B4KF31WlgqfzUT0CRxO9I3Zpo1bLpeddPckkNHvyumyQSIjUS/PIL577ocoLHgahe42UuoVBMhmDgziEHrIJoUdGFxq+CUpst3GCyn7/EGAexSn61/Hxb5e3Oqpwwvb/xz5njr8/emvo8GVTOpzPfhK5SGcr/sJ/qPxLh7M3YY3an6Ovat+DwfMOvz02o/RY7MjJ20PHspZhcsNr+K9lmZ6+Dixo+SzyHZfx9cvvQW5Mg1mhRwjHjW+vPEF7C95Gh39V3HMbsOf7/0zdJA4YEmyCR/ceRuKnOeRoYoPBbdrTW/g9dozMFq8SNUfwmPJWegbriNVyrfRN9iLXmUh/nTzszh++/v4p9OvYnVvBw6XP4MtBg/+6cQ3oEzYAAua8VGfG/9zz2+js/VDvNx0DWKJFs9UPg2LqA8/uPofJI+rgEttwRdWPYY3z/8Fro7I6LszSV5jGAVZTyLflI1zTcfxzd4jsEky8Rvrn0Zr51H8ovYilGI3ctMPk4JfGXoHb+PNuvdIjbAbw5oK/PHGT6Ov/wZ+XPMOxjxy7C38FFab0+Pyt+Uhieif0VtNs82FZPMGPFe6Cw56e3/79qvoJIXBOpccf7nrN3GTfkP/eOpbSEu/g05SZDycmY4fnvxbdEpySQFSglebavFn+/8M0v5L+GHtB6D3fTxS9mmUaqR45eqP0GYVwU6D2ReqP4Mrt7+BD7qGoFWYoJeMQWXYhBfKtuFpUmq7QGpuawuew4b0nZCqS6D0tuKDplN4YcsfTR1H49IX3KjlScDj6MHLl76HG6TSmdz4CR6t+DzMNBtw+s4rONLYjK+kPzjeMDG9oGbDQnLwft13KvQs+uDWK7hGSqN6QxGeLtuPTF0yzSq8h39pfQ0idTm+Ur0D//TB32D7xv8X+c7L+IdLF/BH+34Lp259n5Rob2FEeRz7ip9EoV6/PAFG2OqwA4M1eY/jVvv/QuNgH/LoQeK2d9PUZCP2VHwGh3IHKRIbg15fhS+veRbnh0x4vtKvO7W+8DH88saLuO04hN/b8p8pwjPivRs/Qp84Dw8WZeDfTv1vFCT+PeVTEGF9wUFo+o/jZzfexZ+sroRelYOKRBN63UYYba0krVyPoY5TGJaY8GjlExjqPYtM+nZfqFOjMsGCdzt6I4xn6W5Xlf0oHupohynvU9iVlOIz5E7rJ/RgyMUzG59DJ60BEeYQdpd9Dk39Tmyp/g0Uavzvgg/lluBPz32Iv97/hxRdj8BmvYOXbp7AgVVPo7/1l/jW5V/hDyrWkwRoHnbkl+Pfz/wzzg/uRgItNq3O2ICujisoT1uLO721tMZkGHZJEr60/kn8+8m/wJHWDcgkDfLirD0oErXin66/in0UGNS2noRHWYLPbHoW7YOt8FD+h59e/jly8h5FjrcO/3bum8h78C9gWMg3laVzQ1g1f3L7p+hSVOE/rduBn5z6W7zXXozVuIl2txZPrH0KA4ONJLHqwercJ/FcdzvScz+DTUk0LUrl0ZId+PV3v4t9+/8ef0BS42pXF75D/qkqfQLGkfP49rkf4C+3Pg+PNBmHSlfjvUv/Sv28GRUKDYpSS+AdqEV68gbUdDeivs+MjxtOIdW8Do8VVeBS0zGUZm3yvf+kki5870gPCmjdEBcmEGsExPIkPFX5PAbEl0l597OT7+wb6U1eeO40Dw8iU5kwbrawqHYiKgBuNL2LT/qceKr8Qfzq/N/jQ1LHTRONwCXLwFfXHcK/nfhznOldjVWmDIzYbEhKyoNJeoVmYYG9pc+jtleGA+u/ihxZHA5OC3R02IGBsIhDI9dCPv5dUqrOxuGCjfj3838HsX49vlz9pM8E4XOC8I33XnHBoCvArqw1SB1fs/FyXy2sNO19sqUHZVm7oZWJMSKX4FLjEajsHXCJi+nzgxTJOgsSaGW5yJtA00r9sNnacbOvCYkGF35y9Yc4TQGGPGkX1pqSaApbDAfNsdenrEJenCwOCfxWvqH4cXRd/T7+6qNjOFT+Ikr9xGmKevp6Cg9kJE29FTn6JPr3JPR3HUUdLcirbTtFnJKxNqUADprg94zRjMLdfnTSlJvw7UyjNEKhMcFDCUd0cg1Niw/Rhwsd1qXn08p2GXINabg91IFSkw4N9Z+gj+5io08HQjqETaS330FrPf7yo/fxaNWvkVU21FhboKDZnT7qExtydmD5rkcO8esaH0eaR7uxtegF+oQix8bUCrzeU4uDlXtQMfgD/K+P/pIkwZ9G/vgEvuArMU1lThRh10Ax5a5Yk2imQ5SQyXoTt61tMHdfRCt9qtmQsZp+eQ7IqP9/cPcjNI8MIoE+Iynot5isTIbT1k2/ER00tK6mfZCCEesIvJLz+F7X+/jV9TexrbIVRhoCPV76RKdwoDo5gydKFzhY8mWLS0AYg3xrEaZVI6ZZMS1N/089KqLfBP3P+Ce4xgGagXOIcbrpJM3YbUYm5f2w9Rto3Kqmz9xyZOuS0DLciRSpkhL00W+PPn9qKTmS7+PERJ0rZO1AuB4MOzBwe5wYoe0aavo2I8RqIyO1aHIm4Q93/3daoPYPlKTnEj5TtI7c5cYQndc/0gIrDUkpahfGnKOU6WqMrlP5FuHl6TLQb6zG5wqrac1AE9TuOvzo4pv4L4/8C9wt/4GzNW3oGaHsdA4rrWSlRVVeFUYp41ySZh++sJ4eh2IZurpOoDZlP/ZSsqU+pwzbctbRdyg1FDNuXQwXR+yc56FvzMO2fkhpq6Pbm0TfoT242HwBqwq/ih25N/D1Mz9HueUPkE6Z9xyUEXOQHk5NlGUyNSGXtuqNUgZEGa1F8K/hUKhSkKtJp9md52FyddKbrAanb38d9a5V+JNNhyjhz1l0DHdDNzYMsWYMI8Td5hojvzlpcWcvLnc5KSlSJu4M9aA8X4ufnPsX7Nv+L6j2nMbR4z+nJEAO3Gy/go0lv4FduRfwjQs/xzrzV1GkzUBp9sPYZJSgto8SacVbGV8Ik6PPxJnWj1GqXY8znbdQnfUUJZo6heSUx/BXuXvxjRPfwk1LNap09NmG1oQM2frQ3t9FicEK6Jsm+Yp+H3bylUJYiyAzUmCbjlUFT6JCaUOj1YNbza/io243/m7fl/CS9RbtuOjEgGcIo4pRyuI4Qt9aR9FrHcSjqz6DUouNfC7CkavfwfbKL6GE1hYo9Buw1pJHW62U/Ckh3vpgHLXHSWNOP43zo7RWwDC+xdZN2RlH7NTX6dv/xLozF21HHnEM0+9GOKaizwaZNIspxfPVT6BrsA5SjRFX7a243GnAnhQTGkZ6sS0vBx29H9C/d2BIbsMJ+r1usT6OMqWbMiz2YZiy23qkikVYwL08HRQyMBB2FtybrAGuNr2F28P9qG9+F5XJX0QiveUfu/ltesvPgVpbgkey/Akw8tJ2Ufa57+LlWgc+U3EQp+78ktK+Au/XvIacNU/DTGl2D1U9j5/Q2+U/fXwMFbmPYJcxHw8XbsC/f/x1JBuMKNHIKVtdEw2WVnRRNrphSvE8RlPTVkoz66XppFpauXqurRWPr36BMj+qyY6f4yWaqi4wFqIqZw8KdEb/u/SU6aaldM9C7OjsvYBaazfEtb9AluYFVCeYMEoPhW/c+gRZeh02Fz8Giy/kVWNnwRr8x+XvYG/Fc0i1NeGD1npY6Xv0+6238WBmGdS6Uny+pA3f/PhvkEDbbZ4uPYwNRU/i1sWX8c/nOyiDZglGeq/6FvNIR1oxQos820bb6ccHisDXIW/oDL55+ptITtqHLSmVUBc/gLcufgM3jAmoMCahgT4vua238c8nTiFDq8H24oehk6kpecrj+L9X/xmfyFOxv+hRmm2Klheo7y6y76fef1PhE+ij2atvnjqP1JQd2J2ag9qmi/jOxXeQrTejOOch+szjXyW1s2gnre34CZx5D+MB/QBeqb8Ah92KX9adxacLN1HWxVS8sOog/u+5v8E7NCv3eNljKM44jPLu7+Lrp/4Vem0OFNa7qIedBtB2Cv7skJCvRinl+bDTDRXNLHxy9yR6aN3CF9c8BhmtdfjFlR/jW61a5CUWYB9lx9T7JiwWn1G0vM31xD4B4Wky/YkSaLMDn7ScxSBl9/3xzffwAj07hBnGCw2v4w59RmhtfBvlps/BLHPSYuufoc02hDdv/wKW6qdRkf8oOm3/jr89/k/IStuER2iMK8jchrsNV2jc+ldkpD+KVTRWZRXsxr9c/Bl+NCQk9tsJPY0R11pOops+i//y6k+RWP0MUhWhV64v9pgSS14MGRgI27Gm7hGtznkEwt+9ko8/3v+3QW1RUjatL2z+r5PHtxU9B+FvapEqzPjselpvMKXsLn8hKBtd4M3tYw34wZWfIDGxGI+t+RxSaFGib7AtfQbZnSdxtW8QKuk9x/pWqMZAEeyY7zMx1bwef3lwemaxraVfxlb/94NppSTjIP6Y/ibKf9r5l0HnZKXtxZ/Q32RRFOI3tv1xWHRy107PerYm/3GsCUx8af4iNgfYZqBMnb+7LThjWliV3sdJIpqql4r9qVQXq0ztWyKpFoerpmdJLMx6DH9Df4EljaY6f3/35snDn9/8J0HnmE1r8V93TM04qcWLm39/zqbUtr6HX7bcQWXmdryYVkH7e6jQbNGzG76KU/VH0SvW0ucO/22Ez1TTdgTNeXc+gQksnICw1U/4C13keLDqa/Q3/Yz1tLZN+LtXaD1Axf9Df1PPk9BL0RenZaNNpxeaF+hvakkwrsEf7V4z7Vi29iGsyn4orIYJO45W/HbFXFNBwFqBsNgt6kkKWoz4pY1fnbGOHMtm5Fim/pMcZbRnW5hWXdoioV0TtHc8RjQVlpZFdGpPUFlgWNQFDQqasi8kn0anPeHWUpj+AIS/oCJSYVP+oWmH9YokaJOmzgmGWwufxwTmTyCZPh8v8iTe/I2a5xWFSYVhaTHM87YxefqsMwYxaXHYRtF++hh5GMeKHWGjW+YnCm/Di6tIGDt9a6GuWnxGC7WMr4tHAj5xo6V+R7tPsCvp5S425trv02F8ORNgAkyACTABJhAZAhwYRIYj34UJMAEmwASYQFwQ4MAgLtzIjWACTIAJMAEmEBkCQYGBlzT6x1y0T228iEkzQBCEspNO+0SRiuW0CMOf8niiyCQKEiJywUH7sf1F5EuH7PHSXnjPxApxkU9nwEV7U+8pV5FYC+0kcLoddK5/MZSwqlxIFesY37sqHBOTRraMhF0cdN7EkikJ2Sassp7LNinZJl+C9QbCHlz7FEZSaruYxH4cpKk/lRuImzOQG+lGuOhcf/EzclHbJ7hNMBLS5wqiOX5uUmrndEZ+/5GULl07USTkP6nIO42b33/uKbb5/ecl/zmn+E84JmhauANsW0z/CbbNyCiMvqUU9iZHULzERbzv9XGSHQhlW9j+m9rvF+6/4L414b+5+hb9JknfYMZ8DZEZY/guK5kAjRM23xi1OGN7eGMDjZ8k0DbtuUNrHoRjQeMWPSemPmNmGj+FY8pZcpbEg7uDAoOBwVv40e1j/oUi9FxKMq3GeqOcdPBP+9P30XM/L20bcuUDeL/hmj8jCx2ryt4HjfMOTrY1+I+RatsWWgk9PHAGV3u7x1P/qfBAwT7Utn+AhmGr/5gkEYfzN+N0w9vosfuDCqkqE4eySvHenXdJZ99vh85Qil3JSfjVneOTtqUmrSeNeS/erj83aVsh6cNnSDpxtOnWpG2l2QewhzIxRrvUd3yCdxuvT9pRlrkbJm8LPmqpHWdEktG5B+AeuYwLXe3+Y14ZdhU8iNbuj1A7MOhvl1iPgwU7cJGkPzvG/A94kSLVl2Piw7q3MSxgI0YqXSEeSM3EG3c+8KkRCsfMidXYmKDEG3WnJhnlpG5FgWIIRxquTtpWSf7Tu+pJN7x+0n+b8w7COnQOV0i/3K/8ocTeggdQ33EUd4dGxv2XQP7bgjON76CbcgUIRaLMwGGSST5S9y7ttffbodWXYLfFgtfvHAOJJfqOpdB2otV6Ed6qPztpW0H6DmRKusl/NydtW52zH3L7LZxubxq3TYxt+QcpF8Mp3KBcHX7b1HigcC9uUWbB5hESO/VxM5Dm+lPIUE5P/HU//eBq83v4pL1xmv881qs439k6xX/70db9MWoGBvx2iHQ4ULATl+nadtLl8BV5Ch7OXY1j9W9hSMBG46ZSk4/9adl4k/znI0mMTImrsClRTT49OcV/W1CoHMF7d69MMqrI2guD++4U/5EaZd4hjA2dx+WeznFGCuzJfwCNncdQNzQ8bpsGh8qeJgGs+Mgxcj++5WsjT8Dj6MJPr7/i07IRim9szyzBe5RXZe6x3UNj+/lpY3s6je0fTozt9PtYm/MgxGM3cJZkwv3PHQm2FxxAT+9J3OzvG+/jWjxIGgbXaDtvq9Xmf37Ikuj3t56UX9/CgMMftCjUuSTkloe377xPEub+319CQiW2mfX03PnYfx2NZ0nmtZTCfFPkYcXQHYMCgwRjBX5947RNoj5zf50ytgWWklR/PoR7pRhrArNcJuVgR0DG3qLEF4LulVMdvA3xxXXBqX5/3VQZdO2vJ28MOFaBsvQpe/aXCHghiT0Jf9NLGaoy908/ZMnH5oC4pZySFwWchTzjl4Na8rm1vx507KsbgsUOfj1p6r54/yXFqTuC/FedFXAoOZd+aNOPlSR+Pth/xl8LOvaFtcH++5pphr5FWv+BpSx9T8ChQqzLCThEfWt3wKGihBcX1durSaxodaAdJHi8KW96teWmHARuHMxP+FKQbc+vCfbfr83kP/P0/dfCjYpStgfcr4RUF4P9ty3Af6UkFMOFCUSDgFiRgs/N0MdfXFcUVP3MY3vgA7gC5UFjewE25AbczpyDwBGkIOGLQXV+ZvXXgo59eX3JDLZVRwNXzNTBawxixhVsCBNgAkyACTCBpSfAgcHS+4AtYAJMgAkwASYQMwQ4MIgZV7AhTIAJMAEmwASWngAHBkvvA7aACTABJsAEmEDMEODAIGZcwYYwASbABJgAE1h6AnMGBsOjfZAqDVAF6AAIKSiXRaYp2kfbPzYAgzoxKNf2RH7vaLlhYLQXWrXJn/VuShG2+EZwq320mrN09ZBGQL9tBEZ1QpD8+mL6NFb8N0i/SZUqgdJYTxefXza/yaXrOVwzE2ACYRCYNTDwOPtxoe0a1uZuDbrV0OANvNPRjSdLdgU9cMOoN2qn9A3U4Dptot2alRhU59W7b6NbUYS9aQF7zRbBOuvwXVzu7cXWHFPQ3etbj+KWO5n2/pcvQs3xd8vW7mto8eiwgQKDwPJJzWuQmjZjoyk5og0fHWnApe5ubMsN9t/dtg9xw2kiXYngrbQRNYJu5rR14GJ7PTbn3UvdPFFHR/cZnBoS4bGC4O2fkbaD78cEmED8Epg1MGjoqoExoQBaSXAebb0+B6L6i7hLgi35KlKmi8VCioI1fR0ozNg6Y/BSYM7FxbprcFBgEDkJnJlAeHG7uxHZKeuDZguEs7MoxfVHN09hhAIDbSxyjCWb3FbUDw+hMqd6xmRtRYlpFLBexQbT3ggmc/P7L8eyLrT/bnyC4exK6BY5g1xNZy1SksqhmGGKyUK/VWvzO+hyrUeyIAnKhQkwASawAAIhAwNhtqCZVPbWp6bNeFuRWIP1pGR3ruki8otjUwWqf6AWbkUyUhSyGdug1hUjQ3wKl3p6scEc/Ca4AJ4zXmKlt80RiQFr1JoZ/11GamDFqo9wtq0Ju9MCFWoiZUV83Ke1pwZKXTaMIR58SeZq6Jp+gBpSPyzWRkbNb3SkEcOkXlgdwn9SUnosUXtwlhQR95By4WIVh60d3W4ZtumDZ7+EOsUyE6qNKpxpvoGHcnn2abH8wPdlAvFOIGRg0NDtny1Q++RmZy7ZKWtw4uKr6HRuhEVIqBBTxYXbNFtQkLltVqtWpxfj9dZTWGc+vEifRDz+2QLL+lntqMpYhZ/dOU2zF1mLPHsRU06anzHuUZotGERVbvUs18lQbUnHyZZzKC4JVAacX3X+swX/NSCLZgtm6+GV5L+Xa07DToHBYs2f3em6g1RSjpxtmq80fS3OXz9Gsxfl0M3y210ICb6GCTCBlUFgxjHG6xxA86gdG1JTZ6UgkphQatThdNttPJIdLCO5lAj7+4XZghRY5DPPFkzYlmhaA2XjS6gdsdEbpjLiJo8M09smafavDvG2OVGhRleGRPFpXOkfwLoEY8TtiIcbtvXcotmCHBgksweh2Smb8GH7K+hwbkWK7P6ejtbhJvKfnmYLZv/Io9aWIEnyCS739WNDYvDah/vl7xhrp08EMmw1zH5viTILWdSNz3W1YXfKzLN992sLX88EmEB8E5gxMLjbfRuGhEKowpgEqEpfj2s3zmI0qwTqMM6PDk6Hb21BAa0tmLvIsT45C2daLtMbZmDOhbmvnv0MD2p7mujb9PowvneLKBArxpHW8xQYLH2eh/ttecSvp9mCOlpbsIoSD81Z6LNNtdGIc601tCDwfgJWD2p6aLYgOUz/pZXiXfLf+sR9Yfh7zlZMO+FOdx0lnSrH7GGu/5J1GVV4hRKLuVIemXV2YX4W8NlMgAmsFAJBgYHL3oPGUQc2pc0+WzABSKbKRYbiOE7S99W9i/h9dT4O6eqtgZPWFlgU4S0pzE1dh2PnX0GzbQ0yleEMveFZMzhQhyGx8G1aHdYFKcmrIW36IW4Nb0KJbub1CGHdKA5Pauy67ltboJ9jtmCi6ZUZ63HmyvsYyCyGMcxrArENDtZjSKTHKk14vkhOWgMpzT7doMyT5frILSMds7ag00VZ4/ThzUToDJVIxFlcoF0wG0yLt3YmDrsZN4kJMAEiEJx2mfb8p5uKMZ9lW+sz1uBYbwfdbvEWXoXvLTcGKcVncVJw9q6Q96DUz+st2WgZ7qHAILyAaG57vOh3OFCQVDKPt0c1LfYsRuNwBwUG0U8TPXebluoMB6zUI4spY2G4RazMRJXJjMaRIRgNhnAvm3begMOOguSSeaw9UWJjWjGtg+igwCAgpeGCLPBfJGg25JhL5/H2L8YGmjW4NNJGeZs5MLgP9HwpE1iRBIICA7OxAOZ5otAbK/GwcZ4XLdrpEhSmBKf2nau68uzAJMdzXTHXv4uQkzz/leH56TspiS+X6QTkKEudv0835j90XyCzaVvgfEtu2k4EZoCd7z0Cz08zzf9zSErSBhy434r5eibABFYkgTmVD6dScbqdkIilELNM34rsLNzo2CMg/CalEtk8ZqVirw1sERNgArFFIGRgYLVaIZPJIJff+05/m7YwZtGMgl65WBuyYgvOoltDWsjD9iFoSHL6/tbOL7qlXAERGLENQkm+mlc0vajkXLjRWYNi+tyhlAaLkC1q1XxzJsAE4pZAyDFO0F0X/qYWD+UdWK6lqf0T3HQa8WBWWcw0oa//Nm5aXdicubBv4DHTkCUy5HrT++iVF2BHyuKvbbFZm3G+qx1bc2NLbng5/yaXqNtwtUyACcxBIGRgoNUGr6oWLeMJy1RjBo7cOIXhzLJFl60Nr9c5UTPQgfz0LTxbEB6woLOyDCk4ffcKtlBgsNhv8TXdd5GRRLtGFmjrYl22nH+Ti8WE78sEmMD9EQg5zg0MDEChUFAWt/nsT7g/YxbzapkqC2WaT3COtlXujoFtlf39d+CWC3LN4W2pXEw2y/XeOkM5MsXncIlEhdYtgqjQBBdhtqDfq0aFVrdcUbHdTIAJMIGwCYQMDDS0d1ssjq8v31XpVSQ7fIZkh7OXWHY4PLnmsL24gk9cnVaIt1pPY23igUWazxISKAmzBdU8s7OC+xk3nQmsJAIhAwMR7TwQ/uKpqH2yw6dItnaA1OmMS9Y0v1yzZU655iUzcBlVbDavJVGhH+CO1Y5CTeQXxQriQgNQo1KrX0ZU2FQmwASYwMIJhAwMRkZG4upTwgQiQXb4vdZzPtnapSkOf3KnsOSal8bC5VWrAuuT0nGp5QoKi2dPVDX/dnlR012PDNNqni2YPzy+ggkwgWVKIGRgYCSt+XgsluQ1kPlkh61LIjssyDW7hNkCXlsQse5VkL4BJy68ijb7aqQpIrc8UEiA1e/VoELHswURcxbfiAkwgZgnMC8dA2Fr1PQNjDHfvhkMVGFdSj5qB5opMJi/otz9tdiFPrsLRQtQ1Lu/euP8asryWW1OQd1AJ9Io5XKkSs/oMHKTihHLCgG8XTFS3ub7MAEmMEFgVh2DQEyFSQVQkMraci/5GXuWSHZYipK06uWOLybtr849THZFNmzNsVTGZFvvGSVBSXIB5JL4WiQc49DZPCYQ9wTmpWOgloWXJTDuqXEDY4YAyXDB4/GSVLfwcIyvxbJzQxZBLeff5Nyc+AwmwATmQ2BeOgY3Om8i05gHHekbcJk/AZuDZKblmpiemp5/q5b2ijFHH+72DaI8JS+ihtjJV2IKhGUxvTPHhavttfRpqggKlkSOqP/5ZkxgJROYl46By+0imeT4wXW96UOMqIqwMSlt0RtlH23D2a5WbMpZz4FBBGnTfAGEfjlRztS/B7VpPSoMxgXX4nUO4GzLdazJ3YxYT0/k+00uuKV8IRNgAkwgmMC8lnDHm65BKu1Nf635Mm13S1v07Wg1XXdgMVXRg4ZLZAlM19uwKGU40XaVAoPtC67mbvdtaPQ5UIti/9t9vP0mF+w0vpAJMIGIEZh1V0I8SSLPRCwxsRopzT/AtcFhVBkWT+7WPtaKPq8S23QLf4uNmMfj/EbZqZtI9vplNIxtQo5q/mGYh2YLmsccWJ8Sud0NcY6cm8cEmECcEVhxOgbT/SfGKksWjracocBg76K5tqarDmnmVfwJYdEIT7mxSIkKkxEXWi8jp2DdvGtspNkCgyEf6tifLJh32/gCJsAEmEA4BGZVPpTJZD71w3guaSmURrf1x/SG6aI3zHl9WQkLi220Fb0eJbbrOLVyWMAicFJx+mZ8fPlN9LnXIXEeIgTCbEHTqJ1mCxZ/zUkEmsm3YAJMgAksCoEVlSthZoIarE604GLrdXrDXBVxyHdIUjfdXMWzBREnO8sNZcko06pwvr0BD2TkhF1zU3cNDMYCni0ImxifyASYQDwSmHVXQjw2eKY2lWWsx6mLb6PHWQmzLHJzyKMjzejxyHm2YAk60prMNXjp5kmMpedAFYa8gYu2PTaM2rAxlWcLlsBdXCUTYAIxRGBeOgZujzuutitO+kGWgooEHW70d2BHcqQeDF60D/cgy1zCswWL2OEFgSO3xxNUg1xTiDz1edwaHMJq49y5DrqH2pGUUBRWELGIzZn3rX2/yXlfxRcwASbABEITmFX5UOxTk7tX8s15UNG6g3gsGwqfgJtyQUSuiJCbWk3bIMN4XY1cpSvuTiqpAfnmmdX/9pQ9E7ZPLaYypMa0mNFMrpWgMCmPZMojN8u14joQN5gJMIEgArPmSvAGqBnpFIu3pS8WfCOJ8L51DgoW36sSsRx6pTxkReH6VLzsggKhySJqe3z/Jhe/B3ENTIAJBBKYl47Bra7byDDkQsspg+fsSS6XHZDKIeUZgzlZ3c8Jo84+NJIkcqkld8G3cbsd8IglJH88jy0MC64tkhe6cKOjjmZMKLkZSyJHEizfiwmsaALz0jGw08POHU+ayDO4/lzDMejNa1Gk1S64Y3hdwzjTdBXVuZsgXZZvogtuetQv9HrdsLucs9TrxIn6E8hN3450xQzd3WvH+aazyM/YAJNsuQUGgI1+k7zGIOrdjitkAnFNYF46BmKaao/3L+Z6sQ3nWq6hqGTTgh3f1H0LCl3mspDUXXAjY+ZCEWb/DCCFwtWHs+01SM8pC7K6p68OLrmJgoLQnyNipqkzGCL8JrkwASbABCJJIGRgICw8XIk67EUZW3H50s/RZl+PNMX83yA9rkE0WscoAU9mJP3E91owARHW5WxDzdX3MZRVBv3U56jXgdr+ThRkLTyvwoLN4guZABNgAjFKIGRgoFav0DzvYi1KDBqca7uOR3Kr5u225u5aaA150M4/pph3XXxBeAREcguyVW6c62jCnrSsyYt6++/Aq0pFsjzyipfhWcZnMQEmwARij8C8dAxiz/zFsag8YxNOC2+Y2VXT3zDnqM7rGqLZglGsyctYHMP4rgsmsC5rLV6qOY0dFBj4Or3XiRqaLSjk2YIFM+ULmQATiE8C89IxiE8Ewa0SK9JRpJbgYlcrds4jy16TkK5XmC3gz74x11WU2lJkiE/jaj8JHiXo0dNfA68yFUkyni2IOWexQUyACSwpgZCjoofU5FbiGoMJb6zPXI1/rz2NLSmPIxxJJ49zEA20tmBdPs8WLGmPDlm5COvTS/BGy2lSQtxNswVdPFsQm45iq5gAE1hiAiEDg7GxMcjlcqhUqkkT/ZLIK2NzlEpXijTZOVwfHEa1YW4RmY7BJiQY86GJ920bS9xhA6v3wkOSyO6wrEoyV8PY8SoudN2FVpMZF7MFLpZEDsv3fBITYALhEwgZGBgMwWmCsxOzoZaH8/4cvgGxe6YIByo+A1eYcZAlsQxpJJLDJboElCSJnJOoDK9SkQoPl38aTpK+VkqW5/bE6Q2VIM+UDTlLIofnfz6LCTCBsAiEDAyGh4d9MwYKhWLyRgkqY1g3jZeTxKSEJw9zBkDCQcGSuF0qViBBfa+PzmWERCyNo6RWIiSqV9Zvci7/8r8zASZw/wRCBgYSiSRojUFt9x2k6rNYEjmAu5emcz2kcBiuLv/9u43vMEFgzDmA5oEhFCXd24Y4Kx2aLXDRCdK4EAZy4xZ9Fsk1cSIl/kUwASYQOQIhAwNhbUHg4sNR52jcSyIHo3WSvPE5ypS4kb5Jz7TdwIGLTeeRnb522arnRa47Rf9Obtp2OOoYC7NiL663nENiQjblV2hAReZGaMOcEQqzgiif5qW2j66YdT9RhsvVMYEVSyBkYDA4OOj7jDB18eFKkEQO7glSOKxNON1hxkOZhUH/3EuSuqNSHRKXqaTucu/5IhLpDlcW2GZtQbdLhDJNEi7VvYOLqhxsT7IsawThtn1ZN5KNZwJMIKoEQgYGOp1uRW9XvOcFETbnbsWPb3wCa0bh9F0H9Lbqk9TN3Br3OSSi2isXqbKa7rvITF5N/VqMHbnr8Iv6M9iS9HAcrTlYJHB8WybABFYUgZCBgdvthpAvQfhb6UWizEC63IpL3R3YmpwyiaNv4A7cimSkrJidGsu3J9iszej3qlCh8W891eiLYfB+jBtDI6jULzyT5vIlwpYzASbABGYmMKeOgVTKynACuvWZa/Dju6ewJflT47MDLtT0ddBsASfgWQ4/rts0W5CRtBr3wlwJ1qcV4+3m06gs37scmsA2MgEmwASiQmBeOgZRsShGK9EaKpDkOU9vmKMo16vR119LswUpsHACnhj12D2zxmiNyABUqNROF6pKSVoDRfNP0WR3I2sBmTRjvuFsIBNgAkxgAQTmpWOwgPvH0SUSbEjLxwfNZ1Fevh01ve2crndZeNcN32yBaepswbjhlEmz2pSMs82XkVWwZlm0ho1kAkyACSw2gZCBgfAJIXB9gcvjWtFbo9KS10De8Utc6qyDXJNBswUrRQVysbvhwu8vSCILssChythYJ0ZFBlTq9DOeUpy+BmeufYAe92qYJctv76LvN7lwfHwlE2ACTCCIQMjAQKkMlpnNNGZAJVvBD0OxDo9WPE6SuoBaei+HBPerpSOgkOiQZQwtbyxXmGl9SGrInQdieRo+Xfk4pMtyja0Y2QkZkPEC4aXrgFwzE4hDAvPSMTBrzHGIYH5NUlBAEL4A7/zuzWfPn4BMooJZGzpIk4jlc25HVMvU8684Jq4QI0nLv8mYcAUbwQTiiMC8dAzqe+th0WVCs8Kn0D00eStm5YKY+BnYKN11K2XAzDfPnO7a46Vtt5TzIj6LG7XdjchOzOFESvHpYG4VE1gSAiEDA5fLBSFfwtR1BkP2YZg0niUxNFYqvdlygdIrZ6BtsA2l6dW01p3LUhJweR0YsltnNKGx4zLsqnQUGeZ+q/Y4+3Cuqw3r0iumbGlcypaFU7cXQ7ZheFZIKvRwiPA5TIAJ3D+BkIGBzWbzSSJP1TGQ0JvX8luedf+QJu5gH21Fp8OJYnUiztS+AacqCxsTEyNXAd9p3gQESeSZkld5XYNoGBnA2uSqsO4pojTMtW2nYTDmo1izfMI9zuoZlnv5JCbABOZBgHUM5gGrprsO6UmraBZFil25a/E6bV3ckPjgig6W5oEvqqc2dN2CIaEQWnF4oayIti7uyizGJ80XUVyyJaq2cmVMgAkwgVgiEDIwGBoaglwux0y7E2KpAdGyxT7Wil6PEtt1Bl+VemMJlHWncHvEhhJt8A6OaNnF9QQT8AipmMccWJ+SNi886UkVcDT/DG2OjUiTx+u6hHkh4ZOZABNYgQRCBgYy2pYorDHg4idQ01mPdHPVlBXucqxPzcMxmjUoKWVZ5FjqJ43dt6E35EM13y2IEiOqTCacarmBx/MqY6lJbAsTYAJMIGoE5qVjEDWrYqwiG60t6PUqJmcLJszLtKwD2l5Fh3MbUmThTVnHWNPizhxhtqBpAbMFEyBK09bj3LWPMJJTSZ8h4g4PN4gJMAEmMCeBkIHBwMCA7zOCSrV8FmLN2doFneChLWG0tmDabMH4jegNs9JoxGl6w3w0t3xBd+eLIkuggWYLDDRboF7gQ12qzEQ+dfkznc3Yk5oZWeP4bkyACTCBZUBg1sWHItH0t+CVKIk8NtqOAa8am3XGGd1ZnrGa3jCPoT+rDAnLUFJ3GfTRWU2cKonsETQNbG6sTZ3f2oLACtZkVOAn9aexlQKDWBezYknk5d6D2X4mEHsEQgYGTqfTt8Zg6nbFVH0qlLKVlYZZpjD5JHVDtVqqzMaTFY9AGRBExZ6r49MiuUSDNL1/ekBEKojrsjZAdZ9fdbSGSjxRkjWnYuLSExUj3ZBKksj32eClbwhbwASYQAwRCPmUt9vtvl0JUwODFJ0lhkyPjilSiTJkUDBhgUE582xCdCxc2bUIgUGKXuMPDEj+eN4LDmfEJ0KCajn4VIxU/cr7Ta7sHs+tZwKLTyBkYKDXB2eja+xvRJImDeoVJYks5K7jN7LF74qRqGGl+cqNu70tSDdmsiRyJLoP34MJMAEfgXnpGPSPDsCoTFkx6Jq7rsGuSEFBWJK6/bje34vK5IIVwyeWGtrbfwcdbgXKzZFbMGgf60Ct1Y4Kc3YsNXWKLV700W8yxTBznogYNZrNYgJMIMYJhAwMhM8IgToGgvzqivmU7hpG/VAPVueWheVCEbG50HAMal0WrWoPnQY4rJvxSfMj4LWjpq8JORlb53fdHGeLxW58XHcUycbPI1kam7NGvt9kRFvNN2MCTGClE5g1MAjclbCSYDV234LOWAC9JLx9byKJHjvT83Ch5RLyCzesJFRL3tYemi3wKtOQSrk9IllkinRsNptwqb0G+0kumQsTYAJMYCUQCBkYDA4OrlgdA18CHusY1uXNb4o2x1KJExdeQ7drHZKk4QUUK6GTLWobabagtr8bBZnbFqWakrRyXLh+CqMZxVDzq/miMOabMgEmEFsE5qVjEFumL541Td010BnyoJnvs11qRlmiHidba/BIdsniGch3niTQ0yfMFqQgWb4422jlqjxkqo7jTFc7dllSmTwTYAJMIO4JhBxNHQ6Hb42BkDNhJRUPzRY00mzB2nnOFkwwqkhbi0s3zmCMAoOVrhm56P3G60TNQBfNFixurop1aVX4ReN5eC0P8ff8RXcqV8AEmMBSE5g1MBAWIK60wKCJJHW1C5ktGPekXJ2HHMUnuNDVga3JK2cHx1J05N7+GkCZumizBRNtMiRUwdhwFdeGrKgc10xYivZynUyACTCBaBCYl46By+OG1yvsFY/P4kvAM+rAmtz5rS0IpLE2oxQvN3yC9cmPg/cnLFJf8dpQ09+DwqzI7kSY2Vop1lnS8V7jSVRU7oupWQPfb3KREPNtmQATWJkE5qVjkKxNgkK6ON9yYwI/qRyuyVx/31n1DAnVeESWhfkuUYgJBsvGCDEqMjZAFyWJ7ozUHTigH4oxOmJYdEmQsiRyjPmFzWECy5tAyKe88AkhUMcg3XB/yWliHZVYrIQ2Iq/4EqRQEMVlEQmI5NBFdnfi7MZSfala8yI2aCG3FiPTGN+/yYVQ4WuYABO4PwIhAwNOt3x/YPnq6BCwkxBV18goPSA5Z0B0iHMtTIAJxDuBOP4uEO+u4/YJBJyeMXSP9HNgwN2BCTABJhAhAhwYRAgk32ZpCIhoJYeUZIG5MAEmwASYQGQIcGAQGY58FybABJgAE2ACcUEgKDAYHW3ByY7b/sbRPii9Nhu5aikud9XBt8zeAyQZi5AkGcUNSvk6cSzTVA6FuxN3Bnr8WYq9IhQmV2Fs9C5aRmg1t09OVo5ySxk6B2+iZ8zuPybWYlVyPup7rmHY5fZVK5GZUGVKxXXKbuig+gQ7VKo0FOt1ZMdt//Ys+g+jLhdZSuBK991JO1ISipEgGsbNvrbJYznmCoidbagf7Ju0Ld+yFjlaw6I6sXPgFq71tk7akZZYCp23H7f7OyaP5SVVwm1vRuPQwDgjKUqTK9A3XIPO0dFxRipUJRejqfcaBpwun80iqRGrKJPg7e6rGBOwEQ+50oJyYyKudN6EjyQd05H/8tQy4nbnnv8MhUiWjeF6z3T/Kd1dqB3oHj9PhAKyzT7WgOZJ/8lQZilH9+AtdI/Zxm3TkP8KKP3vNQw5/f4TyxKxypQ2zX9K8l8JpfK+3HVr0n8G8l92gP8sxmIkiqf4j26ZZqpAacLiriEYGmnE2U5i5Ou7QII+HxkKF652N05yS00ohR7T/ZdLjLz2FjQM9Y/7T4IS8t/AcC06JvwnUqHSUozmvusYcDjH/WdANWVtvNV9xe8/KjJFMiqMZlzpugG30MnpT6uhpFwa+TT/mcl/FpmN/Nc8aVtGYhlUnh7yX9fkseyk1SjQJy5qH+ebMwEmEH8EggIDr9cDh8sxOUA6aJ+0hx7yDjcdEwYrGsSEvdMesct/njCLS8fcHg/9jR8TAgi6xk33cnsc/mvHdeY9dMzldt47Rup1wjGnx07HKAqgOiRi/zHhuonAQEL39nrdsAv3Gn/oOckON+kqTLeN6pxqG93SRbYJ1/vs9dlGx6Kgx+CZqHMqI2rvJDeyzcdN4DFhG0VeAjeX0PYJbh7pOCM65qLAgFiKRE7iMc5oPDCA2+U7T2AkxFNCO52+Y+JpjHzc6G+q/wSfTvpPsNfj95/LM8VXwmHBV1Nt88rv+co9HhiM+8933nhgJx73n9CmicDOScdm7Fui6X3LRXUudvFQ35rkLfQPwTaBUWC/n2rbuP+8AqPJviUJ5iaS3OPmosBA+C2Q/+6x9PsKUoGHv86JwMDPSBJsR6D/hN/a1L4l/E6jwG2x/cL3ZwJMIPoEggIDDb2hHCzKCrLkIL1BBZb0hPKAQ2nIC9ylp09GWYDEfJp2d9C9kjUPBh3bmx+sTX9Qlx1sm6Eo6FhmYmXAsVQUJEcXcGpiBYS/6SUD2ebqgGMpKA4QSczU7UTgWRbNA0EN2JV3MOjYg4XBAk0H9Xkz+C8wpXQ6cgP9Z7AE+S99Rv/tD7r/nhn8d4DSUgeWg/QGHFgygvy3uL4z6vJwkP6CbKMZjOklE1mmVUH+KwqY0MjSJSPoLM2+oPvvnMF/+wvC818azWBML+S/WNtRubhu47szASawCAR4jcEiQOVbMgEmwASYABNYrgQ4MFiunmO7fQS89D/CZxEuTIAJMAEmEBkCHBhEhiPfZYkIyEitMlGzuItIl6hpXC0TYAJMYEkIcGCwJNi50kgRUEh1yE7QRep2fB8mwASYwIonEDIw6B7phEpmgFZB+8livdAOA69I5FvsPTrWhW7afJBtSKbV83bIJPcE9T1eO9ppW2A6LaiLXvGgbbATSVoL2cJplcLn7kbrYBdSdCm0S2V8S8sMFzvcVvRYR5Gmj0xuis7hDsrBkAg1pRyPreL17eAQUNjtPWgbcyLXmAqnywaZ9N5v1Ot1oG2oD2mGlJjKAhlbLNkaJsAEZiMQMjDoGelGgoaSCoURGIw57RRERDOjTUCTKCi42vgW+mRlyHBewWVHFpT2W/hRQxt+Z8Mzkyf7A4PuKAcGXrQPd8KoTuLAYF6/RTc94DqRrKXAYJbrhMCgQ3gQRigw6CJfSUlbI/YCAxFqW4+g0ZuFMkkjTg3qYEQrvnPjKv7Tli9MYeSkPt7pCwy4MAEmwAQWQiBkYCAhmVkxPXCnlu+f+u9IzPwcHk4f307lHsDPr/6EBuZhjKpz8Ztrn4Rippc7rwtjtC9eJYm8dK3d1oYjdz/BwFgzjrW9jxQZ7fMnoZhbzcMwGivx4+tv4EDRQSTIhLd10ZLI50rF0oi9vTW3voZvt9jwZxufnre/7c4xKGSqeV+3VBcI3OYqkZZElgi+Cuj3c9ng/3cPCRV5qI/PbXN497t3lsvRjSP1x9Bv68TRljeRIieNCWkCGjpHodaW4qfXfom91MeT5bLxPh55G+ZrM5/PBJjA8iUQ9gjSN9KEwrRdyDf7xQCczkGcuPlDfNBpw2+u/xTkYg2kFBQ4HL2oJ/U8pTIROaRhMGrrwuuXvo8uVSkO5W5AHh1rH6iHSJlCD3Ev6ob7kKnPpOuBflKf6yJBxGLThFaBF3d7bsMtTyQFt2RY7X0YddnhIgVFJQnNOKlOs0SNXFMxPXiL4HK8hh/fOgIVBQZlllUo0hiRn1BE9w49Fb2cXOdyDpHuXgoeK0ifZnbnYC0GvToUGSfeEj1o7K2BgzilGnOgJcGnm03v4md3b+GRik+hKDEfEmcvWkdtyEvIoDfMBkjkFiQrKWjwWHGbFPWSE4uQIPV/+hiyNqPNOoacpCIovTb02YcwSiqHOoUaI3ZhGj81YoFP7PnDhZruOhj1uUhW+D8vuJwDpPDZAbnciFx6M3fYe/HO1R+iTpyBh/O3ooCOdQ3ehUtmRppSirqhLqTraRaL+uEQKYu2jzpQZM6bZNbUewt2iRGF5L8xez9GqI87vVKoJR7YoKRAQIls8kcOSkgXyYqXKNiVkTpoSWo1cjSJKEwohErMn6lir++wRUxgeRIIOzBo77+Bn116E5/dXgULDZA2euBf6qzHmEOB0x21eKLkEJyjzfjl7Tfpm6cZRxo+xm/v+yvorU043X4JowoH0ul7sRAY1HccwXdvXcK+ggdxsvEont7858h3N+LVprP0EPPiSk8xnijchB+d+weMyAvgGKvD6rynkDL2If7x6jmY1MkwKFSweY34re1fQrbWjo8bjyPBvA//dGAPuu0m5Omc+PbZr2NM8ptYkxwfgYHD0YMjt34OceI+khz2z9qcrfkZ3uqqh5aishzzbjxesB5nal9BrV2K7raPIE9/DF8rXUUyyadxta0Z6QnZSCWxI9lYC/7txD/CmLQfasd1jGo24Peq9+D1yz/FiFSPwYZP8Niqz8Ha+TZ+1HgXFQYN3m+9jS+Xrcffv/9fAXURTV9L6IHkxIaSF7EnJW15/gJmsdrrHsaPzv4LOkSJFAi/gYfKX0S5zo1fXn+FJKlN+IDe4l/c/ZfIdrfiVNtFdIn6qI+TkBYFBo09H+ObV45jV8FDuND0Pg6u+0OslfXilfpPoKOA61xnHZ4p3YNXL/4z2kRZkDvv4m7GoyjDFfz1+SMwadIp8FKSiqUaX9v+NeRS8HWykfyp34R/PrQDrVY1yUTL8f2z/4QhfB7rUoJFvuLOIdwgJsAEokIg7MCgPPMA9lEgYLVZyTAtdLpCPFf+CN4dUOL5sk0+Y62uMfTRv5dlrcef5+2m77QSqFXr8HzFw+iUbcKDOTm+87aWPIlXb51EZto+PFPxKMnPjuFfj/0IqqS9yKEH+vfp4bQ1ZyuqUjeiVyRHZ8NlvNd8G7+bn4et+SnIJC19t6oAXd3XcLPzAi7WfYKctM14MGs1Prn1YyRlVCBZp8PvbPtDXOoboEVbpIQcB7GBWpOHF1Ydxs/qSZefittWj6Ottfja7j+EmeYS/vrov6E1Zz2sY5QTggKqhzf8AUwKml4W6/F09QsY9Z7HF1Z92t+x5NXYnpqDk041fn/HX8FL0rtX776CD3sH8WRpKU7d+B7ealyDxyhHw7pUJRIoAHjz6vvoq9yD0qQ1KM/eiusUaBTp5bhDC1Upo0FUOmw0K7nT/A7aJUX4vfWPobP9TXyn5kOUrd6CvrFh5Gesxp/s+XOolXIKyqrw+apP4barGI8U+NUI1+c/ideuvw9z0lb8feUjJE/swPdOfAN27SaUJ6jwg0s/wcac3ShN2QCjW4SR9lq813gFW6uysSn7AArUdEySjuH+W5RP4SJu1p9AavJ6HMzZiPO1P4HO8gASKQ/Cb277Y5ztbvdJg0sW9AkkmkS5LibABJYDgbADA6Exwsp/pfTeIkM76fYLWvoTRaMvwtPlD9ND/zUcb1Dh8/QwUlMCmCH7CJwSf/If30OapquTSGq2MlHjOyYVudHjGEOpQkPfd8V4Yd2Xofa240rHFSQkrKIZCBW0NJ0qrHmQ0doHkUgKmTAI0n8L/yWWyNHadxHf7z2JI9deQ1ZHCwoNlDyG6nJAjUJLJSwUpMRDcVJuBfn4TguXawhyhZGCAqEkwEgzOT02B3ZXfg6nan+Fly5+HRvznsOhbCNGafp/TNDpF/xIDxHhO7pXrMOGtGrfMRF9Wx8Y7YZYoQNN2mBbyefpc0IObra9RUmw5DAkGCjQ0xF/MS2iFLqNCAqpzOdP4b/jq/ijyCH7AFL0fj7J2kzaAXCeAqpkPF35OH5561Uco1mVz65+AQVapa+PO+jz1mQfF1np80M+JUoyjfdxkG9GkGLWEjo5nl/3NZil/Xi74xKUuhLIaWeBVqLy93HiK/RrgbWI8iz4PhJQH+8YvIYfXL6ED6/9HEmpdShLtPg+R9jdcuQmVyJDuYQLgOOrA3BrmMCKJhB2YCCsMbjVXYtu1S1UmjZBJbLjTt81yj4nRmN2KbJ1ZrR2vo/XW4ZxuOhpHL35MmqGepGp0UBFi6IudJ/DBVkfUijjm4cyz93pqaUscs3YlJxJgYEKG+nNtNFuxSZaX9BhF8M22oSz7Y34nYJP4WLfMdyh2YFr9PmgdVhMD6NB+tCrQF3vbVRUPIMvb1zjc+I5WvPgXf8H2G/S4fqAFTvzd9K0bRxMFYx3URet67hOmfdqemh3xehWpNJ0frL0OM0gnKD39Q44ZTSNrXTje2e+izX5j+BxerCcoKyVnmzhwaOmNRrN+KjxDAkCWejbtBK3yAcO52VsS01FglyBYstqmPvPwqhKp1mHDqikElxrOQ1FxheRoRvAoLURl1qvoWmgBVp9K5oG2+ibtxdtcnrYxVXxpXlCUdo2fECfz07RrEh96/uoTj+AscFz+GFtHR4ueBLS2z/F7b4OCgwM1McVaKBPZudVo0iiPA9Sxx1fH7/c2YjEtGzIRTJspMyU1+zDSLeU+LYbuuxtONNSg1/b8QgaRy/RYsLruNoxRH18CDI7LWaUe9FBfTyj6DF8ccNqn03X7vwH7NW/g0fIZ1d6erGtYCctrA37ZxxXXuLGMAEmsDgEQo4oQpY34c1yonQO3EEipVaGux1WUqBViUdpqtOAUr0Ht2khlhAYmOkNSel5Ex/UDSMl7QB2p/oT5qylh3vHtVfQ4VagmhZjfdTUhw1Zm9HWVwenEBjQt+qD1V/Cu7d+hmPNA9hZ+DBS1Pn4UvUgjtcfRVbKXnzaaIVL6kG+ker20myAnBY7ppbBOVSDj2lxXGNfLezSPDxTtQcGSvfYb/0V/u7of4FWlYPHaeYiTyvMTiyNfK4g2XuP5MId6XD0o8OlQkGiEk0jAxQYZOKZNc/jlzd/jlsw0dvr49BQIJRnSMDZux9AQQtAn6o66HvjFKuK8HDxOnzSdReP0zT4UP9lmo1ZR/8wTGsyxnyBgSV5Kz5Le+XfaziGnNTNtBhRh+c2/BZerTmO8+JMfHHNc/DSwrji9LU0g6OjtMxZ0NBMkFpGTlmEEo7UsV8SOXLZF91T+r2O3uS/UG7DL+9eRJJpJx7OKYXH0Uapl89SHz8Kc/JuPJjpT7JUlnMYLdafodkhQrVaiTMd7ViXtR09gzWwC4EBvdvvrvoCxDWv4FjjWWwueBhmnRZfWfcoTtG9MpI34zNqKxzkrEIT6YeIPBTUaqGhPi4ebcAnvR1ooM8KVqTj2cqDtOjWQwsZ38HXj/0BzeSk43D1F+i3KChALk0fXwT38y2ZABNYIgIhAwOtQj9tirg0g74tT0v6loBHKr8wzWwFPYQ/v/5rQU0Riw14uOrFyeM7i57EzsCzaHp1f+lnph2tzDqAyuBkfNPOGbPW453uQXpDfhIlhonUchKsyfsUKtK2oNXmRLrav0VP+ARhVOmjjFoEg8oQke+/ak0OnqMHwNQipm1rn6r84rRjO0qexY6gVopQkr6P/vz/YDSvw4v0F1gyLVvwIv1NFK02D59dE5x1cPEhislXBt+U+mxFKqbPHKrIzVjoqd/Lpfd+FubEarxIfxNFLE/DZ9b9P8F9XKTGgYrPTx7fnP8pbA5KSCrBzqKnpl1bkr5n0ieh2umyNeON7j5UZT+KioSJnSdiVGYfpMyXG9BEAk+p2gkGS9HHF783cA1MgAlEj0DIwCDDOMcTOXo2zlqTihbkfaps5geXXJmM3CnCjRIavPPN0W6XGPmmnBihtZzMkKLAPDc3pdSAPHrDjlTJpnUVsVakykw8Wp45o1kSuQm59DdRRCIF9fHYa0OsMWV7mAATCE2AP05y71jWBJzuUfSP2WhxIH1e4sIEmAATYAL3TYADg/tGyDdYSgJ29whaBvo4MFhKJ3DdTIAJxBUBDgziyp0rrzGRlkReeQS5xUyACTCB6QQ4MOAewQSYABNgAkyACUwSCAoM7KT7XjPQ5j+B9tiplEmkEU9aBZQ62KemQsf0mlToxQ60DPdOHjPpMiHzDKDDOjx5LMWQDae9C722Mf8x2piYaczAgLUVw85xYSSxknIqpKBjuBE2t39Tn1iipe2PiWgebCLFOL8pMnkC0lUqNNDe+Qnb1KpkmEm+vonS807YZtSmQSMao73gpA44bm8S6dSLXH3oGh2ZPGYx5tN2PPWidoVBamcT5YKYsCNBmw4VbThro62GE8eSyTYv5S3oHiNFSR8jMWV/zMLIWBsG7ZQ/WjhGOzayDWnoHmmmXBG0V1QolCMiR9COGGqCc3y3npTSZGdqdGggnQEfNvoPpdKMFIWUuHVM95+E/Ec6ExN2mHQZkHuG0G4dmu4/B/lvbMJ/EmQYMmmbXCuGJv2nIP+lonO4yZdESCgi8l9OoP9k5D+1muxonea/JPJf4xT/GTRpJIs93X8JuixkaCK3wHAmp4/aulFH224neGjUFphoe2wTZeOcy39w9VLfmu4/K/lvYIr/ssh/veQ/64T/xJTjgzJCtg41wjHuPwn5L4v810j+8x2a6r8hsm38mE6dAqPUieYp/ksk/ykC/Gc25CI1gjs2FvXHwjdnAkwgZggEBwaOPlzrvOYfDGl0SjSWQqWT+Y8J4oH0XMqg0TxDNkzHaiePFZOKntLVhGvdNPALG+cpm6KUkh9Zh+tQS9+A/fJtCuiURjTRfuxWSsrjq4O0EBIpGU9dzw30O/wPPYkiFSZSKrxJokak8+IbIDW0bc4gTpxmW1JiBeRqLx27PmlHtlcJi0RoQ/3ksTJauS6xN+BaDw2uPtvov5SpUQkMrpEm/gS3fNoVYfR2km2Nk8cqSQPANVqPm330ABJs88qgViSgs78GjcMUyPhECLRIIE2B+t4bpJ7nD6hE8iQKiuSU4OeaT1fC9xBRZyNBkoIbXdcEN/namWAsgVqvmOa/dLMMmXIrHauZtKOI6tC4W3Ctq2X8mIjE9hIwNlKHmv57/tMqE9Dcf5v8NzruPz35T0tiU9cpudKE/1LINgkJYl2Dbdx/gpyzQWLCdepHJJXgs82cUA6FVjTNtqxkSho01X8kJphH210XOzAYo8DA18fH+4fFJIZU5aRjNycZ5ZKKpknURccaJo9VkP+8Y3dxvZeCU5//pJTEKwHdA7VooKyjvmMiDYw+/91ENylT+golWDKTUmENCVCNCIKJgoIk6VIkStJwg7j5AmJiZDQUQ21Q3bONEKeZ6WerGKNjtyftKCD/6ab5DyiRJXFgEDNDLRvCBJYPgaDAQE85EJ6tKgxqwbOJJG4UUHKTAvfB56AsUDI/MR3rJpIljl+fY/hU0L3S9dP3dwsnPF4evLVwRttMVUH3y0/eGHAsCxXTkxIuupeykjdA+Jte8lGUck8nwPdvpkxUB+xGyzemIeAsZOifDLL5kbJng449VRm8ffPZhLIZ/Lc20KOUsS/gUGIG1ga4IdfwaFj+e2wG/z1TVTBD36oMw3+L6y6TsQzP0l9gyTJVB/mv0LI54FgmqqZpfAAF5L+gs/RPBN3/4dJg/33aMJP//DkYppYcs1/x817JDfbf4mLjuzMBJhCHBHiNQRw6lZvEBJgAE2ACTGChBDgwWCg5vi4mCAiSyB5v5CSRY6JRbAQTYAJMYAkJcGCwhPC56vsnIKHkRBq5X/KaCxNgAkyACdw/AQ4M7p8h32EJCaho8V9hknEJLeCqmQATYALxRSBkYCBkVhTNlcEmvlhwa5YhAZfHhkGbHSb14m5nXIZo2GQmwASYwIIIhAwMBgcHoVAooCLtAC7Ll0BrXz10pD2gl8imNcLpHIGVttYZ5VOyTC3DZtpcQ5Ryu48Dg2XoOzaZCTCB2CQQMjDQaDQQi33iA1yWKQE7iezc7m/HFmNuUAvsY0346Z2b+PyaJ0hdYvkWlkRevr5jy5kAE4hNAiEDA+EzAn9KiE2nhWtVbVcd0pMqoRT7JBWnFa2+BHnya7je3481CQnh3pLPYwJMgAkwgTgnEDIwGBkZ4U8Jy9j59tE29HoU2Ko3hmiFGKtTsvBm0ykKDA4u45ay6UyACTABJhBJAiEDA6Mx1AMlktXzvRaLQG33HaSSIuRs205M5mqom17C7REbirXLe63BYnHk+zIBJsAEVhqBkM8Nq9UKmUwGOenxc1leBBxj7ehxK7At5GzBRHuUWJ2chTOtl1FcHCghvbzazNYyASbABJhAZAjMul0xMlXwXaJNoLbrDtJobUE4IhV5qRvw8YXX0enaCEs4F0S7MVwfE2ACTIAJRJVAyEeBVquNqiFcWWQIWEca0emWYafOGN4NJYkoM8pxrOECnioITMoT3i2W9ixBEnk8N/fSGsK1MwEmwATigkDIwGBgYIAXHy5DF7tEcpSnVPoyPYdbVmXuhKd/MNzTY+o8sUgKpYw/d8WUU9gYJsAEljUB1jFY1u4LNt6gScV8NQClylSsTw3Mt7w8wKhkCShJ5u2Wy8NbbCUTYALLgQB/VV4OXoqQjYNjg1DLtZBJ5jOfEKHKF+k2Lo8dVrsTBhV/+lokxHxbJsAEVhiBWXclsCRyfPWGhr4GZCcWwRhHMteCJHJ9by9WZ5TEl7O4NUyACTCBJSLAOgZLBH4pqpWIJXGnZkn6nBDaxYUJMAEmwAQiQ2BW5UNBw4B1DCIDmu/CBJgAE2ACTGA5EJg1V8JyaADbyASYABNgAkyACUSOwKy7EiJXDd+JCTABJsAEmAATWA4EWMdgOXiJbWQCTIAJMAEmECUCsyofisXiKJnB1TABJsAEmAATYAKxQGDWXAlelpqNBR9FzIb49KcX8dmuiLmdb8QEmAATmBcB1jGYF67lfbJMIou/7YoiCQk2sU7X8u6ZbD0TYAKxRIB1DGLJG4tsS4kl/kSA1DJKApWSuMjk+PZMgAkwgZVDYFYdA5lM5kukxCU+CFgdViikKkjjaO2I2+uEzemCRq6KDydxK5gAE2ACS0wgZGAgLDwUiURLbB5XH0kCdT11yBIkkZXKSN52Se815hzAne4+VKcXL6kdXDkTYAJMIF4IhAwM1Gp1vLSR2zFOQCyiYC/OaAiSyEK7uDABJsAEmEBkCLCOQWQ48l2YABNgAkyACcQFAdYxiAs3ciOYABNgAkyACUSGQMjAwOPx8BqDyDDmuzABJsAEmAATWDYEQgYGY2NjvsyKKhWv9l423mRDmQATYAJMgAncJ4GQgYHBYLjPW/PlTIAJMAEmwASYwHIjEDIwGB4e9s0YsI7BcnNpaHvjVTo4XtsVPz2PW8IEmMByIhAyMJBIJLzGYDl5MgxbJWLyaRjnLadThO2KQru4MAEmwASYQGQIhAwMhLUFLHAUGcixchdBElkUZ3v+1XKWRI6V/sV2MAEmEB8EQgYGg4ODvs8IvPgwPhwttMLhdlDCIQUkcaRo6fG64XC5oZSxdHf89FRuCRNgAktJIGRgoNPpeMZgKT2zCHXXdtWSJHIhDHElidxPksj9WJVetAjE+JZMgAkwgZVHIGRg4Ha7IeRLEP64xAeB+Pw0RKsM4mgGJD56GreCCTCB5UxgTh0DqZRz3S9nB7PtTIAJMAEmwATmQ4B1DOZDi89lAkyACTABJhDnBFjHIM4dzM1jAkyACTABJjAfAiEDA+ETAq8vmA9KPpcJMAEmwASYwPInEDIwUMbRyvXl7yZuARNgAkyACTCB6BBgHYPocI6JWrzwxoQdkTYiXtsVaU58PybABJhAOARYxyAcSnFyjiAfHI8lXtsVj77iNjEBJhD7BEIGBi6XC0K+BF5nEPtODNfC4uRiyisQX9tP1bJElFqM4SLg85gAE2ACTGAOAiGfEjabzSeJzDoG3IeYABNgAkyACawcAqxjsHJ8jdtdt5GZUBBXksijzj7U9fSjKq1wBXmSm8oEmAATWDwCs+oYyGQy8O6ExYMf7TvH6yK9eG1XtPsH18cEmAATEAjMqmMgrDHgEj8E4nWRXry2K356HreECTCB5USAdQyWk7fYVibABJgAE2ACi0wgZGAwMDDg+4ygUqkW2QS+PRNgAkyACTABJhArBGZdfMjpbGPFTWwHE2ACTIAJMIHoEAgZGDidTp+OAW9XjI4juBYmwASYABNgArFAIGRgYLfbIZfLOTCIBS+xDUyACTABJsAEokQgZGCg1+ujZAJXEy0CXm885kqgzYpx2a5o9QquhwkwASYwnUDIwGBoaMg3Y8A6BvHTZQqTCyGTKOKnQdQSFUkiF1sMcdUmbgwTYAJMYCkJhAwMhKCAdQyW0jWRr1sukSPeFpSKRWLIJfGZHCryPYDvyASYABOYm8CsgUG8PUTmxhHfZ9zqvIUMYx70tA01XorV0Ye7vQOoSM2PlyZxO5gAE2ACS0ogZGAwODjIOgZL6prIV+72uBF/qwy8ENrFhQkwASbABCJDgHUMIsNxWdwlXmeA4rVdy6JTsZFMgAnEHYGQgYHD4fBtVWQdg7jzOTeICTABJsAEmEBIArMGBsJVHBhw72ECTIAJMAEmsHIIsI7ByvE1t5QJMAEmwASYwJwEWMdgTkR8AhNgAkyACTCBlUNg1u2K/Blh5XQEbikTYAJMgAkwAd8SglAYBIEjXu0dX53E4/XE3XZFEkSG0C4uTIAJMAEmEBkCrGMQGY7L4i755nwopPJlYWu4RqpkRhQmacM9nc9jAkyACTCBOQiwjsEK6iIauSbuWisRyaCRy+KuXdwgJsAEmMBSEZg17bKwxkAm40F3qZwT6XoFSeQ0Yy70ivhJpDTq7EMDSSKXpeRFGhffjwkwASawIgmEDAycTqdvjQEHBvHTL5xuZ9ylKPZ63XC6XfHjJG4JE2ACTGCJCbCOwRI7IJrVx+diUhEvko1mJ+K6mAATiHsCsy4+VNCUszKOMvHFvTe5gUyACTABJsAE7pNAyMBACAgkEsl93p4vZwJMgAkwASbABJYTgZCBgbDwUCwWL6e2sK1MgAkwASbABJjAfRKYVRJZmDVQqVT3WQVfzgSYABNgAkyACSwXAiEDA6PRuFzawHYyASbABJgAE2ACESIQMjCw2Wy+lMu8XTFCpGPgNm6PO/62K5IkstAuLkyACTABJhAZAiEDA5fLxWsMIsM4Zu6SY8qBWhZfkshKqR55Jv7cFTOdjA1hAkxg2RMIGRjodLpl3zhuwHQCBqUh7pBIxQoYVPGj5Bh3DuIGMQEmsOwIsI7BsnMZG8wEmAATYAJMYPEIsI7B4rHlOzMBJsAEmAATWHYEZtUxiE8J3WXnIzaYCTABJsAEmEDUCIQMDIaHhyFIIrOOQdR8wRUxASbABJgAE1hyAiEDA4PBwMlpltw9kTGgvfcC3m64DAgK17SzLyt5A3IUwzjefHPyWFn6DmjcjTjb0eg/5hFhXdYejA5fxo2+HsAngqnE9twdaOz6GE0jVkBEhyRG7Mtej0stR9Hj8Gc5lCjSsC+9CMcbP8SYsJPQC2i1hdiSlIT3Gj4R/l+6P5BsWoVKrQjvN16atCM3ZRPSJH34uLVm8lhl5i7I7HdwoavFb4dXgo3ZuzEweAG3+/vGbZNje8EjKOBFs5HpNHwXJsAEViyBkIHB2NiYT8OAdQyWf98wanOwM9fof5DTU1mtNEErdtKx5MljenUyZB4t1KqcyWOJGhPcyjVIMtj9xyhiSFInQJu6CblOCgKEYyI5TOpErMnYBrvH98iHSKxCglqHzVk74RYO0Z9UpkMizUDtyNnpB0rHlAojDFIR2UG7JcZt0yrNUInN2ClPnTxmVCdB5FFBp8kfPyaCiWxLUqxFitExbpsYSSrl8ncWt4AJMAEmsMQEQgYGbrebkygtsXMiVb1KkYg8+gsswkN4etHCoA44pNDAFHBIJ88KupfakBt0LNuoDTqWJ9cHH1MkBB3TKZOCbEsIsk2NwLMixYzvwwSYABNYqQRYx2Clep7bzQSYABNgAkxgBgKz6hjI5XJefMjdhgkwASbABJjACiIQMjAQdiNIJMIqNC5MgAkwASbABJjASiEQMjAQggLWMVgp3YDbyQSYABNgAkzAT4B1DFZQT6jrqYNFnwktfSKKqeL1oG9sAIm0u6Gn/wpuWeXYlpaLmr4m5JsLfbsnheL2jOJOTweKk/Niynw2hgkwASYQTwRYxyCevDlHW6wOK1weEhCYUlyOHtzs7YDJkI002mK4JEUkRmPHUbw6loStWisGXKm42vAa3uxy4T9NCQwowTJGHKNLYiJXygSYABNYKQRm1TGQSqUQFiByiQ8CYnoA++QIJoq9Cf/3wi+QTFkX322+iq+tfxaqaSeMn+joR7dXRboBkdcJsI024qc334CDHvrXO4/izb5aSJQpyNRbUJm6Dt89/0M8VvkMLHKhq4ogtIELE2ACTIAJLB6BkIGBh94svV6/YA2X+CMwOtqMl8/9K04OSPHFtTvwgKUKSgoK2vsu4XxnC1xSHQ4U7sTo4E387xP/gD5VOR4u2oc9GeW43PgeBqQZqNIr8X7LNWzLO4gUhRSXmo+gadSD7fn7kUA9y2Zrx7G75+EgQaXDuZvRO3ANtwa64BHroZc4YJckYaMlH8+u/grGxtrxJl6FyzVGi15NyKJPHh7qf/uKHoZZxotg468HcouYABOIVQIhAwOtNlicJlYbwXbNn4BYLIdeYUKyhmYRKP6TiCWwUhDwxp1PsCFzO9699SvUpa1GpkRF3/5JgEhigF6u8lWkljrwtx/9KXaWf4muqUFz6jb0tJ7BpVEXiqnb/PDC9/Gl1c/ih+e/h+SMg3D2HMXLbgW2Kmvws+sXkK7WQ0HBgt3hQXbiFzHQdQHnu++gOPMx7MvfjV5PFoopsvjByb/EkeZMfLVsy/wbyFcwASbABJjAggiEDAwGBgY4idKCkC6Pi5RKC7ZkrMVQvxjbM1b7jHZSoKAV2/FR6ykcWv1llGmENQd6bElfhXbpeqwbX/RXmL4JWbp3sTX/QZSqH6Rz7PjrM29AadyERq+LFg3eRL9XhgcKduPjzhvo621El7cbhwqysKPAgnTRIDyqfHR2X0Nd1xl8cucUKrK2wCCz42eXf4KM3E/TzIEMGws/g7tDvRh1e6CW8CeE5dGz2EomwASWO4GQgYFarWYdg+Xu3bnsF9G3gynf7L1SAx6r/hpqOz7Ga5f+D0Yqfg0bzBYM20fg8U3nuzHqEtOMgReJugxkTUoUe2hrqwrllBthk1GDLdn7oLDfwPevH8HT638dvRIr3nfKIBHqox0IXvpvESVLED5UGbVZqLD0w2bvwsXGazjZUY9CvIceYxblVpDD5lXCRjkY1Pw1YS5v8r8zASbABCJCIGRgIBbTFLMwkHOJSwJe9yCONxzBsU4XChOTsS21CL09H+DvLp3B/vztSFNZKJGhf41JSkIajte+Ard9FTbm7sb1pndxvuU8Xq05jSeKNlLORRUO5m3CL++8ArspGzJNITYmiGG3D+JW60k09zei3tqPD0Vq3B4RYdA7CK/Whsb2i8gvfRaHSnOoljG8Q7MFj239b9hvlOO9uxdRkLwO5YlplIiJ+2FcdkJuFBNgAjFJIGRgMDIywp8SYtJlCzfK5XFNLigVkYRFSc7DyM3wQDm+diA1eQc+W6HHiNOLTSVPoNjgT7JUlPEQnqQFgU5FFi0ylGFAXYzf2f678Eo1/mzMVFblPwaj4QKaR91YnVEGWrpA53wNV7tbcaD6t3HYMUwfHFzIo88CUiHnskQBe0oZlCOX8IObZ32fC3IsO/FYRrHvflszhvGTK/+KV70mPL3uyyjwrXnx0nZLIY8zFybABJgAE1gsAiEDA6PRuFh18n2XiEC6IR0qSqXtKxINVqVtmG6JWIPqjK0zWleSunnyeEnK2hnPyTavQfaUfzFoc7GN/vxl5jyIbmcfHB4ZcpPLoZ4yMZCUUIXf3Fk1rR6xSIFMI6Vj5sIEmAATYAKLRiBkYGC1WiGjhwjrGCwa+6jfOEkbe0mKJbJElFuCU0LPBEcskiNFF5gqOuoYuUImwASYQFwTCBkYCBoGrGMQ177nxjEBJsAEmAATCCLAOgbcKZgAE2ACTIAJMIFJAqxjwJ2BCTABJsAEmAATmDsw0GhoxTltWeTCBJgAE2ACTIAJrBwCIWcMWMMgfjpBd/91HG+9RTsRqE202y/VVIUMuRVn2+smj+WnrIfa3UrbC9v8xzwiVKRtgs16C3cG+uHflyjHuowNaOs9j7bRMSGnEZ1LyohplbjRcQoDTv9WQrE8GVssuTjXeprEiegAySGoNdlYk5iIj1su+tUR6LjJWIIijQgnW29O2pGRVA2LeIDyNTRMHitK3QCZoxHXezv9dnjFWEXqi0PD13F3cHDcNhnWZe9FNgW0XJgAE2ACTGDhBFjHYOHsls2VCrkewlZF34OcHsgJSi2pF8qQrqdjwoOWjhnlaig8JjpGJ/keviLoSN9A4UlGupckDn1bCWVQyxQwaVIhktr9x8QqKKVKJOvSoHH5UzqLSUFRKVUhVZcOhxAF0J9CkQAF6R4IdfoCA/oPnUoPlVw0zbZEBdkmpmN656RtBrJNIjbTMequ44GBVqakqsk2kL6BzzYptYnlEZdNp2RDmQATiFkCrGMQs66JnGF6TSY20V9gMetyAg6ZkWoMOKRJQI5p+rEklT+3wtSSoArQRKB/XJMecCEd26i2BF27SZMRdCxZnxdwjIIWyuU0rZBtgWdFjhrfiQkwASawMgmwjsHK9Du3mgkwASbABJjAjARCBgbMiwkwASbABJgAE1h5BEIGBsKuBC5MgAkwASbABJjAyiLAOgYry9/cWibABJgAE2ACsxL4/wEvk9SHCXLt0gAAAABJRU5ErkJggg==)

 

输入流

输出流

流迭代器

Ios：抽象基类

由ios派生出类istream和类ostream

 

| **数据类型** | **描述**                                                     |
| ------------ | ------------------------------------------------------------ |
| ofstream     | 该数据类型表示输出文件流，用于创建文件并向文件写入信息。     |
| ifstream     | 该数据类型表示输入文件流，用于从文件读取信息。               |
| fstream      | 该数据类型通常表示文件流，且同时具有 ofstream 和 ifstream 两种功能，这意味着它可以创建文件，向文件写入信息，从文件读取信息。 |

要在 C++ 中进行文件处理，必须在 C++ 源代码文件中包含头文件 <iostream> 和 <fstream>。

#### Fstream

打开文件

在从文件读取信息或者向文件写入信息之前，必须先打开文件。**ofstream** 和 **fstream** 对象都可以用来打开文件进行写操作，如果只需要打开文件进行读操作，则使用 **ifstream** 对象。

下面是 open() 函数的标准语法，open() 函数是 fstream、ifstream 和 ofstream 对象的一个成员。

void open(const char *filename, ios::openmode mode);

。

**cin** 是预定义的**输入流对象**（**istream** 类型），不是类。

**open()** 用于打开文件流，不是生成新流对象。

| **模式标志** | **描述**                                                     |
| ------------ | ------------------------------------------------------------ |
| ios::app     | 追加模式。所有写入都追加到文件末尾。                         |
| ios::ate     | 文件打开后定位到文件末尾。                                   |
| ios::in      | 打开文件用于读取。                                           |
| ios::out     | 打开文件用于写入。                                           |
| ios::trunc   | 如果该文件已经存在，其内容将在打开文件之前被截断，即把文件长度设为 0。 |

**关闭文件**

当 C++ 程序终止时，它会自动关闭刷新所有流，释放所有分配的内存，并关闭所有打开的文件。但程序员应该养成一个好习惯，在程序终止前关闭所有打开的文件。

下面是 close() 函数的标准语法，close() 函数是 fstream、ifstream 和 ofstream 对象的一个成员。

void close();

**写入文件**

在 C++ 编程中，我们使用流插入运算符（ << ）向文件写入信息，就像使用该运算符输出信息到屏幕上一样。唯一不同的是，在这里您使用的是 **ofstream** 或 **fstream** 对象，而不是 **cout** 对象。

**读取文件**

在 C++ 编程中，我们使用流提取运算符（ >> ）从文件读取信息，就像使用该运算符从键盘输入信息一样。唯一不同的是，在这里您使用的是 **ifstream** 或 **fstream** 对象，而不是 **cin** 对象。

**文件位置指针**

**istream** 和 **ostream** 都提供了用于重新定位文件位置指针的成员函数。这些成员函数包括关于 istream 的 **seekg**（"seek get"）和关于 ostream 的 **seekp**（"seek put"）。

seekg 和 seekp 的参数通常是一个长整型。第二个参数可以用于指定查找方向。查找方向可以是 **ios::beg**（默认的，从流的开头开始定位），也可以是 **ios::cur**（从流的当前位置开始定位），也可以是 **ios::end**（从流的末尾开始定位）。

文件位置指针是一个整数值，指定了从文件的起始位置到指针所在位置的字节数。

 

Ofstrean myfile（“filename”）

Ofstream类支持磁盘文件输出

如果在构造函数中指定一个文件名，当构造这个文件时是自动打开的

在调用默认构造函数之后使用open函数成员打开文件

Ofstream myfile

Myfile.open(“filename”,std::out,std::binary)

输出格式状态实在类ios中的枚举值，用于指定输出数据的格式，所以在引用这些格式的时候

使用输出流控制符输出格式

输出流控制符 实在头文件iomanip.h中定义

Setpricision(n)

Stew（n）

Setfill(n)

Cout.Set(ios::left)

流迭代器：用于从输入流中粗去数据；迭代器自增时时，读取流中断下一个值

输入和输出是指数据传送的过程，数据向流水一样从一个地方流向另一个地方，C++将此过程称为流（stream）

Copy(int input iter,std::back_inserter(data))

Back_inserter通过调用容器opush_back()方法实现输入操作

自动扩容：当存储空间不足时自动调用push_back()扩容

合并多个容器

合并多个容器

复制文件

Std::copy(part 1.begin(),part1.end(),std::back_insert(combined))

Istreambuf_iterator

直接读写缓冲区字符的迭代器。

不进行格式化

将二进制数据写入文件

文件拷贝

读取图像

直接读取缓冲区

将所有类型转换为字符类型

 

Cout/cin流对象

Auto：自动识别数据类型

插入运算符<<

提取运算符>>

函数调用的时候

New 与malloc

Delete []p

Int *只是一种定义，实际上是q=&m

Int & 同样q=m;

 

### 遗留的问题

是的，**std::sort** 要求比较器必须是一个 **二元谓词（Binary Predicate）**，即能接受两个参数并返回 **bool** 值的可调用对象。具体规则如下：



**1. std::sort 对比较器的要求**

- **输入**：两个参数（容器中的元素）。
- **输出**：**bool**（表示是否第一个参数应排在第二个参数之前）。
- **严格弱序**：比较器必须满足以下条件：
  - 反对称性：若 **comp(a, b) == true**，则 **comp(b,      a) == false**。
  - 传递性：若 **comp(a, b) && comp(b, c)**，则 **comp(a, c)**。
  - 不可反身性：**comp(a, a)** 必须为 **false**。



**2. 为什么必须是二元函数对象？**

**std::sort** 的排序过程需要 **任意比较两个元素** 以确定它们的相对顺序。因此比较器必须：

- 能独立接受两个参数（不能依赖对象实例状态）。
- 不修改被比较的元素（除非明确使用 **mutable** Lambda）。



**3. 四种实现方式的二元性验证**

**（1）嵌套比较类（Functor）**

cpp

复制

下载

class compare {

public:

  bool operator()(const obj& a, const obj& b) const { 

​    return a.getA() < b.getA(); 

  }

};

- **二元性**：显式接受两个参数 **(a, b)**，符合要求。

**（2）重载 operator<**

cpp

复制

下载

bool operator<(const obj& a, const obj& b) { 

  return a.getA() < b.getA(); 

}

- **二元性**：虽然是成员函数，但作为自由函数或友元时，仍接受两个参数。

**（3）普通函数**

cpp

复制

下载

bool compare(const obj& a, const obj& b) { 

  return a.getA() < b.getA(); 

}

- **二元性**：直接满足二元谓词要求。

**（4）Lambda 表达式**

cpp

复制

下载

[](const obj& a, const obj& b) { return a.getA() < b.getA(); }

- **二元性**：Lambda 的 **operator()** 隐式生成二元函数。



**4. 为什么成员函数形式的 operator() 不行？**

你之前提问的以下形式无法用于 **std::sort**：

cpp

复制

下载

bool operator()(const obj& rhs) const { return a < rhs.getA(); }

- **问题**：这是一个 **一元谓词**（隐含依赖 **this** 对象），而 **std::sort** 需要能比较任意两个元素的 **二元谓词**。
- **错误示例**：

cpp

复制

下载

sort(v.begin(), v.end(), obj::compare()); *//* *错误：compare 必须能接受两个参数*



**5. 关键总结**

| **比较器类型**       | **是否满足 std::sort 要求** | **原因**                                                     |
| -------------------- | --------------------------- | ------------------------------------------------------------ |
| 二元函数对象         | ✅ 是                        | 显式接受两个参数（如 Functor、普通函数、Lambda）。           |
| 重载的 **operator<** | ✅ 是                        | 作为自由函数或友元时是二元的。                               |
| 一元成员函数         | ❌ 否                        | 依赖 **this** 对象，无法比较任意两个元素。                   |
| 静态成员函数         | ✅ 是                        | 可定义为二元函数（如 **static bool  compare(const obj& a, const obj& b)**）。 |



**6. 最终结论**

**std::sort** **必须使用二元函数对象**，因为它需要在排序过程中动态比较容器中的任意两个元素。四种实现方式中：

- **嵌套比较类**、**普通函数**、**Lambda** 直接满足二元性。
- **operator<** 需定义为自由函数或友元函数（二元形式）。
- 成员函数形式的 **operator()**（一元）**不满足要求**。

所以说opertaor《即可是一个参数也可是两个参数？？