《C++高级编程》读书笔记（七：内存管理）

1、参考引用

• C++高级编程（第4版，C++17标准）马克·葛瑞格尔

2、建议先看《21天学通C++》 这本书入门，笔记链接如下

• 21天学通C++读书笔记（文章链接汇总）

1. 使用动态内存

1.1 如何描绘内存

• 在本书中，内存单元表示为一个带有标签的框，该标签表示这个内存对应的变量名，方框内的数据显示当前的内存值
• i 是在栈上分配的自动变量，当程序流离开作用域时会自动释放 i

  int i = 7;
  

• 使用 new 关键字时，内存分配在堆上。下面的代码在堆栈上创建一个变量 ptr，然后在堆上分配内存，ptr 指向这块内存
  • 变量 ptr 仍在堆栈上，即使它指向的是堆中的内存
  • 指针只是一个变量，可在堆栈或堆中，然而动态内存总是在堆上分配

  int *ptr = nullptr; // 每次声明一个指针变量时，务必立即用适当的指针或 nullptr 进行初始化
  ptr = new int;int *ptr = new int; // 等价于上面两行代码
  

• 指针既可在堆栈中，也可在堆中
  • 下面的代码首先声明一个指向整数指针的指针变量 handle
  • 然后，动态分配足够的内存来保存一个指向整数的指针，并将指向这个新内存的指针保存在 handle 中
  • 接下来，将另一块足以保存整数的动态内存的指针保存在 * handle 的内存位置

  int* *handle = nullptr;
  handle = new int*;
  *handle = new int;
  

• 下图展示了这个两级指针，其中一个指针保存在堆栈中 (handle)，另一个指针保存在堆中 (*handle)

1.2 分配和释放

• 要为变量创建空间，可使用 new 关键字。要释放这个空间给程序中的其他部分使用，可使用 delete 关键字

1.2.1 使用 new 和 delete

• 内存泄漏
  • 要分配一块内存，可调用 new，并提供需要空间的变量的类型。new 返回指向那个内存的指针，但程序员应将这个指针保存在变量中。如果忽略了 new 的返回值，或这个指针变量离开了作用域，那么这块内存就被孤立了，因为无法再访问这块内存。这也称为内存泄漏（当堆中有数据块无法从堆栈中直接或间接访问时，这块内存就被孤立/泄露了）

  void leaky() 
  {new int;cout << "I just leaked an int!" << endl;
  }
  

• 除非计算机能提供无限制的高速内存，否则就需要告诉编译器，对象关联的内存什么时候可以释放以作他用。为释放堆中的内存，只需要使用 delete 关键字，并提供指向那块内存的指针，如下所示

  int *ptr = new int;
  delete ptr;
  ptr = nullptr; // 建议在释放指针的内存后，将指针重新设置为 mullptr。这样就不会在无意中使用一个指向已释放内存的指针
  

1.2.2 关于 malloc() 函数

• 在 C++ 中不应该使用 malloc() 和 fee() 函数，只使用 new 和 delete 运算符

1.2.3 当内存分配失败时

• 默认情况下，如果 new 失败了，程序会终止。在许多程序中，这种行为是可以接受的。当new 因为没有足以满足请求的内存而抛出异常失败时，程序退出。
• 也有不抛出异常的 new 版本。相反，它会返回 nullptr，这类似于 C 语言中 malloc() 的行为

  int *ptr = new(nothrow) int;
  

1.3 数组

• 数组将多个同一类型的变量封装在一个通过索引访问的变量中

1.3.1 基本类型的数组

• 当程序为数组分配内存时，分配的是连续的内存块，每一块大到足以容纳数组的单个元素。例如，在堆栈上分配 5 个 int 型数字的局部数组的声明如下所示
• 下图展示了创建这个数组后的内存状态。在堆栈上声明数组时，数组的大小必须是编译时已知的常量值

  int myArray[5];
  

• 在堆上声明数组没什么不同，只是需要通过一个指针引用数组的位置。下面的代码为包含 5 个 int 型数字的数组分配内存，并将指向这块内存的指针保存在变量 myArrayPtr 中
• 堆中的数组和堆栈中的数组类似，只是位置不同而已。myArrayPtr 变量指向数组的第 0 个元素。把数组放在堆中的好处在于可在运行时通过动态内存指定数组大小

  int *myArrayPtr = new int[5];
  delete[] myArrayPtr; // 对 new[] 的每次调用都应与 delete[] 调用配对，以清理内存
  myArrayPtr = nullptr;
  

不要把动态分配的数组和动态数组混为一谈。数组本身不是动态的，因为一旦被分配，数组的大小就不会改变。动态内存允许在运行时指定分配的内存块的大小，但它不会自动调整其大小以容纳数据

1.3.2 对象的数组

• 对象的数组和简单类型的数组没有区别。通过 new[N] 分配 N 个对象的数组时，实际上分配了 N 个连续的内存块，每一块足以容纳单个对象
• 使用 new[] 时，每个对象的无参构造函数 (= default) 会自动调用。这样，通过 new[] 分配对象数组时，会返回一个指向数组的指针，这个数组中的所有对象都被初始化了

  class Simple
  {public:Simple() {}~Simple() {}
  };
  // 如果要分配包含 4 个 Simple 对象的数组，那么 Simple 构造函数会被调用 4 次
  Simple *mySimpleArray = new Simple[4];
  

1.3.3 多维数组

• 1. 多维堆栈数组
  • 在内存中，堆栈中的二维数组如下图所示。由于内存中不存在两个数轴 (地址只是顺序排列的)，计算机将维数组以一维数组的方式表示。多维数组的大小是其所有维度的乘积，再乘以这个数组中单个元素的大小
  • 要访问多维数组中的值，计算机将每个下标当作多维数组中的另一个子数组。例如，表达式 board[0] 实际上指下图中突出显示的子数组。添加 board[0][2] 时，计算机通过子数组中第二个下标访问子数组，从而访问正确的元素

• 2. 多维堆数组
  • 如果需要在运行时确定多维数组的维数，可以使用堆数组。正如动态分配的一维数组是通过指针访问一样，动态分配的多维数组也通过指针访问。唯一的区别在于，在二维数组中，需要使用指针的指针：在 N 维数组中，需要使用 N 级指针

  // 编译器并不自动分配子数组的内存。可像分配一维堆数组那样分配第一个维度的数组
  // 但是必须显式地分配每一个子数组。下面的函数正确分配了二维数组的内存
  char** allocateCharacterBoard(size_t xDimension, size_t yDimension) {char** myArray = new char*[xDimension]; // Allocate first dimensionfor (size_t i = 0; i < xDimension; i++) {myArray[i] = new char[yDimension];  // Allocate ith subarray}return myArray;
  }
  // 要释放多维堆数组的内存，数组版本的 delete[] 语法也不能自动清理子数组
  // 释放数组的代码应该类似于分配数组的代码，如以下函数所示
  void releaseCharacterBoard(char** myArray, size_t xDimension) {for (size_t i = 0; i < xDimension; i++) {delete[] myArray[i];    //  Delete ith subarray}delete[] myArray;           //  Delete first dimension
  }
  

建议尽可能不要使用旧式的 C 风格数组，因为这种数组没有提供任何内存安全性

• 这里解释它们，是因为可能在旧代码中遇到。在新代码中，应改用 C++ 标准库容器std::array 和 std::vector
• 例如，用 vector 表示一维动态数组，用 vector<vector<T>> 表示二维动态数组等
• 如果应用程序中需要 N 维动态数组，建议编写帮助类，以方便使用接口。例如，要使用行长相等的二维数据，应当考虑编写 (也可以重用) Matrix<T> 或 Table<T> 类模板，该模板在内部使用 vector<vector<T>>数据结构

1.4 使用指针

• 思考指针的方式有两种

  • 指针只是一个内存地址
  • 指针只是一个间接层，它告诉程序 “看那个地方”（指针箭头的意义）
    • 当通过 * 运算符解除对一个指针的引用时：从地址的角度看，把解除引用想象为跳到与那个指针表示的地址对应的内存；使用图形视图时，每次解除引用都对应从箭尾到箭头的过程
    • 当通过 & 运算符取一个位置的地址时：从地址的角度看，程序只不过是表示那个位置的地址的数值，这个数值可保存为指针形式；在图形视图中，& 运算符创建了一个新箭头，其头部终止于表达式表示的位置，其尾部可以保存为一个指针

• 指针的类型转换

  Document *documentPtr = getDocument();
  char *myCharPtr = (char*)documentPtr; // 正确
  // 编译器将拒绝执行不同数据类型的指针的静态类型转换
  char *myCharPtr = static_cast<char*>(documentPtr); // 错误，无法编译
  

2. 数组-指针的对偶性

前面提到，指针和数组之间有一些重叠

• 在堆上分配的数组通过指向该数组中第一个元素的指针来引用
• 基于堆栈的数组通过数组语法 ([]) 和普通的变量声明来引用

2.1 数组就是指针

• 下面的代码创建了一个堆栈上的数组，数组元素初始化为 0，但通过一个指针来访问这个数组

  int myIntArray[10] = {};
  int *myIntPtr = myIntArray;
  myIntPtr[4] = 5;
  

• 下面的函数以指针形式接收一个整数数组
  • 调用者需要显式地传入数组的大小，因为指针没有包含任何与大小有关的信息（任何形式的 C++ 数组，不论是不是指针，都没有内含大小信息，这是应使用现代容器的一个原因）

  void doubleInts(int *theArray, size_t size) {for (size_t i = 0; i < size; ++i) {theArray[i] *= 2;}
  }
  

• 这个函数的调用者可以传入基于堆栈或堆的数组
  • 在传入基于堆的数组时，指针已经存在了，且按值传入函数
  • 在传入基于堆栈的数组时，调用者可以传入一个数组变量，编译器会自动把这个数组变量当作指向数组的指针处理，还可以显式地传入第一个元素的地址

  // 传入基于堆的数组
  size_t arrSize = 4;
  int *heapArray = new int[arrSize]{1, 5, 3, 4};
  doubleInts(heapArray, arrSize);
  delete[] heapArray;
  heapArray = nullptr;// 传入基于堆栈的数组
  int stackArray[] = {5, 7, 9, 11};
  arrSize = std::size(stackArray); // 从 C++17 开始
  // arrSize = sizeof(stackArray); // C++17 之前的写法
  doubleInts(stackArray, arrSize); // 把数组变量当作指向数组的指针处理
  doubleInts(&stackArray[0], arrSize); // 显式地传入第一个元素的地址
  

• 数组参数传递的语义和指针参数传递的语义十分相似，因为当把数组传递给函数时，编译器将数组视为指针
  • 函数如果接收数组作为参数，并修改数组中元素的值，实际上修改的是原始数组而不是副本
  • 与指针一样，传递数组实际上模仿的是按引用传递的功能，因为真正传入函数的是原始数组的地址而不是副本
  • 以下实现修改了原始数组，即使参数是数组而不是指针，也同样如此

  void doubleInts(int theArray[], size_t size) {for (size_t i = 0; i < size; ++i) {theArray[i] *= 2;}
  }
  

• 在函数原型中，theArray 后面方括号中的数字被忽略了。下面的 3 个版本是等价的

  void doubleInts(int *theArray, size_t size);
  void doubleInts(int theArray[], size_t size);
  void doubleInts(int theArray[2], size_t size);
  

通过数组语法声明的数组可通过指针访问，当把数组传递给函数时，这个数组总是作为指针传递

2.2 并非所有的指针都是数组

• 指针本身是没有意义的，它可能指向随机内存、对象或数组。始终可使用指针的数组语法，但这样做并不总是正确的，因为指针并不总是数组。例如，考虑下面的代码
  • ptr 是一个有效的指针，但不是一个数组。可通过数组语法 (ptr[0]) 访问这个指针指向的值，但是这样做的风格很可疑。事实上，对于非数组指针使用数组语法可能导致 bug。ptr[1] 处的内存可以是任意内容

  int *ptr = new int;
  

通过指针可自动引用数组，但并非所有指针都是数组

3. 低级内存操作

3.1 指针运算

• 声明一个指向 int 的指针，然后将这个指针递增 1，则这个指针在内存中向前移动 1 个 int 的大小，而不是 1 个字节

  int *myArray = new int[8];
  myArray[2] = 33;
  *(myArray + 2) = 33; // 等价于上一行代码
  

• 指针运算的另一个有用应用是减法运算。将一个指针减去另一个同类型的指针，得到的是两个指针之间指针指向的类型的元素个数，而不是两个指针之间字节数的绝对值

3.2 自定义内存管理

• 大部分情况下，new 和 delete 在后台完成了所有相关工作：分配正确大小的内存块、管理可用的内存区域列表、释放内存时将内存块释放回可用内存列表
• 资源非常紧张时，或在非常特殊的情况下，例如管理共享内存时，实现自定义的内存管理是一个可行的方案

3.3 垃圾回收

• 内存清理的另一个方面是垃圾回收。在支持垃圾回收的环境中，程序员几乎不必显式地释放与对象关联的内存，运行时库会在某时刻自动清理没有任何引用的对象
• 与 C# 和 Java 不一样，在 C++ 语言中没有内建垃圾回收
  • 在现代 C++ 中，使用智能指针管理内存
  • 在旧代码中，则在对象层次通过 new 和 delete 管理内存
  • 在 C++ 中实现真正的垃圾回收是可能的，但不容易，而将自己从释放内存的任务中解放出来可能引入新麻烦

3.4 对象池

• 垃圾回收就像买了一堆野餐用的盘子，然后把任何用过的盘子留在花园中，等着什么时候有风把这些盘于吹到邻居的花园中。当然，必须有一种更符合生态规律的内存管理方法
• 对象池是回收的代名词。购买合理数量的盘子，在使用一个盘子后，就清理它供以后重用
• 使用对象池的理想情况是：随着时间的推移，需要使用大量同类型的对象，而且创建每个对象都会有开销

4. 智能指针

内存管理是 C++ 中常见的错误和 bug 来源，许多这类 bug 都来自动态内存分配和指针的使用

• 在程序中广泛使用动态内存分配，在对象间传递多个指针时，很容易忘记每个指针只能在正确时间执行一次 delete 操作
• 出错的后果很严重：当多次释放动态分配的内存时，可能会导致内存损坏或致命的运行时错误，当忘记释放动态分配的内存时，会导致内存泄漏

• 智能指针可帮助管理动态分配的内存，这是避免内存泄漏建议采用的技术。这样，智能指针可保存动态分配的资源如内存。当堆栈变量离开作用域或被重置时，会自动释放所占用的资源。智能指针可用于管理在函数作用域内 (或作为类的数据成员) 动态分配的资源，也可通过函数实参来传递动态分配的资源的所有权
• 智能指针的主要类型
  • 1、默认智能指针 unique_ptr（唯一所有权），独占对象
  • 2、共享资源智能指针 shared_ptr（共享所有权），允许多个 shared_ptr 实例指向同一个对象，通过计数管理
  • 3、weak_ptr 是辅助类，是一种弱引用，指向 shared_ptr 所管理的对象
  • 使用智能指针时，需要添加 <memory> 头文件

4.1 unique_ptr

4.1.1 创建 unique_ptr

• 作为经验法则，总将动态分配的对象保存在堆栈的 unique_ptr 实例中

  // 故意不释放对象，产生内存泄漏
  void leaky() {Simple *mySimplePtr = new Simple();mySimplePtr->go();
  }
  // 如果 go() 方法抛出一个异常，将永远不会调用 delete，也会导致内存泄漏
  void couldBeLeaky() {Simple *mySimplePtr = new Simple();mySimplePtr->go();delete mySimplePtr;
  }
  

• 上面这两种情况下应使用 unique_ptr。对象不会显式删除，但实例 unique_ptr 离开作用域时 (在函数的末尾，或者因为抛出了异常)，就会在其析构函数中自动释放 Simple 对象

  // 这段代码使用 C++14 中的 make_unique() 和 auto 关键字
  // 所以只需要指定指针的类型，本例中是 Simple
  // 如果 Simple 构造函数需要参数，就把它们放在 make_unique() 调用的圆括号中
  void notLeaky() {auto mySimpleSmartPtr = make_unique<Simple>();mySimpleSmartPtr->go();
  }
  

• 考虑下面对 foo() 函数的调用

  foo(make_unique<Simple>(), make_unique<Bar>(data()))
  

始终使用 make_unique() 来创建 unique_ptr

4.1.2 使用 unique_ptr

• 像标准指针一样，仍可以使用 * 或 -> 对智能指针进行解引用

  // 以下两种方式等价
  mySimpleSmartPtr->go();
  (*mySimpleSmartPtr).go();
  

• get() 方法可用于直接访问底层指针，这可将指针传递给需要普通指针的函数

  void processData(Simple *simple) { /* 使用普通指针 */ }auto mySimpleSmartPtr = make_unique<Simple>();
  processData(mySimpleSmartPtr.get()); // 调用
  

• 可释放 unique_ptr 的底层指针，并使用 reset() 根据需要将其改成另一个指针

  mySimpleSmartPtr.reset(); // 释放底层指针并设置为 nullptr
  mySimpleSmartPtr.reset(new Simple()); // 释放底层指针并设置为一个新的指针
  

• 可使用 release() 断开 unique_ptr 与底层指针的连接。release() 方法返回资源的底层指针，然后将智能指针设置为 nullptr。实际上，智能指针失去对资源的所有权，负责在你用完资源时释放资源

  Simple *simple = mySimpleSmartPtr.release();
  delete simple;
  simple = nullptr;
  

• 由于 unique_ptr 代表唯一拥有权，因此无法复制它。使用 std::move() 实用工具，可使用移动语义将一个 unique_ptr 移到另一个。这用于显式移动所有权，如下所示

  class Foo {
  public:Foo(unique_ptr<int> data) : mData(move(data)) {}
  private:unique_ptr<int> mData;  
  };
  auto myIntSmartPtr = make_unique<int> (42);
  Foo f(move(myIntSmartPtr));
  

4.2 shared_ptr

• 总是使用 make_shared() 创建 shared_ptr

  auto mySimpleSmartPtr = make_shared<Simple>();
  

• 与 unique_ptr 一样，shared_ptr 也支持 get() 和 reset() 方法。唯一的区别在于，当调用 reset() 时，由于引用计数，仅在最后的 shared_ptr 销毁或重置时，才释放底层资源

• 注意：shared_ptr 不支持 release()。可使用 use_count() 来检索共享同一资源的 shared_ptr 实例数量

• 与 unique_ptr 类似，shared_ptr 默认情况下使用标准的 new 和 delete 运算来分配和释放内存

• 下面的示例使用 shared_ptr 存储文件指针。当 shared_ptr 离开作用域时 (此处为脱离作用域时)，会调用 CloseFile() 函数来自动关闭文件指针。这个例子使用了旧式 C 语言的 fopen() 和 fclose() 函数，只是为了演示 shared_ptr 除了管理纯粹的内存之外还可以用于其他目的

  void CloseFile(FILE *filePtr) {if (fillPtr == nullptr) {return;}fclose(filePtr);cout << "File closed." << endl;0
  }
  int main() {FILE *f = fopen("data.txt", "w");shared_ptr<FILE> filePtr(f, CloseFile);if (filePtr == nullptr) {cerr << "Error opening file." << endl;} else {cout << "File opened." << endl;}return 0;
  }
  

4.2.1 引用计数的必要性

• 引用计数用于跟踪正在使用的某个类的实例或特定对象的个数，引用计数的智能指针跟踪为引用一个真实指针 (或某个对象) 而建立的智能指针的数目。通过这种方式，智能指针可以避免双重删除
• 如果要创建两个标准的 shared_ptrs，并使它们都指向同一个 Simple 对象，如下面的代码所示，在销毁时，两个智能指针将尝试删除同一个对象

  // 应该避免使用这种方式，改用下面的复制构造函数
  void doubleDelete() {Simple *mySimple = new Simple();shared_ptr<Simple> smartPtr1(mySimple);shared_ptr<Simple> smartPtr2(mySimple);
  }
  

  // 输出：代码崩溃
  Simple constructor called!
  Simple destructor called!
  Simple destructor called!
  

• 只调用一次构造函数，却调用两次析构函数，使用 unique_ptr 也会出现同样的问题。连引用计数的 shared_ptr 类也会以这种方式工作。然而，根据 C++ 标准，这是正确的行为。不应该像以上 doubleDelete() 函数那样创建两个指向同一个对象的 shared_ptr，而是应该建立副本，如下所示

  void noDoubleDelete() {auto smartPtr1 = make_shared<Simple>();shared_ptr<Simple> smartPtr2(smartPtr1); // 建立副本
  }
  

  // 输出
  Simple constructor called!
  Simple destructor called!
  

即使有两个指向同一个 Simple 对象的 shared_ptr，Simple 对象也只销毁一次。回顾一下，unique_ptr 不是引用计数的。事实上，unique_ptr 不允许像 noDoubleDelete() 函数中那样使用复制构造函数

4.2.2 别名

• shared_ptr 支持所谓的别名：这允许一个 shared_ptr 与另一个 shared_ptr 共享一个指针 (拥有的指针)，但指向不同的对象 (存储的指针)。例如，这可用于使用一个 shared_ptr 指向一个对象的成员，同时拥有该对象本身
  • “拥有的指针” 用于引用计数：当对指针解引用或调用它的 get() 时，将返回 “存储的指针”
  • “存储的指针” 用于大多数操作，如比较运算符

  class Foo {
  public:Foo(int value) : mData(value) {}int mData;
  };
  // 仅当两个 shared_ptrs (foo 和 aliasing) 都销毁时，才销毁 Foo 对象
  /*创建一个名为 foo 的智能指针对象，它使用 make_shared 模板函数来动态分配一个名为Foo 的类的实例，并将值 42 传递给该实例的构造函数这个智能指针对象可以自动管理这个实例的内存，确保在不再需要时自动释放它
  */
  auto foo = make_shared<Foo>(42);
  /*这种构造方式称为 "别名构造函数"，它允许多个智能指针共享同一个对象，同时避免智能指针在释放对象时出现问题创建了一个名为 aliasing 的智能指针对象，使用 shared_ptr 模板函数并传递两个参数第一个参数是上面创建的智能指针对象指向动态分配的 Foo 实例第二个参数是 Foo 类中名为 mData 的成员的地址
  */
  auto aliasing = shared_ptr<int>(foo, &foo->mData);
  

  make_shared 和 shared_ptr 的区别
  • std::shared_ptr 构造函数会执行两次内存申请（首先会申请数据的内存，然后申请内控制块）
  • 而 std::make_shared 则执行一次（将数据和控制块的申请放到一起）
  • make_shared 的缺点
    • 因为 make_shared 只申请一次内存，因此控制块和数据块在一起，只有当控制块中不再使用时，内存才会释放，但是 weak_ptr 却使得控制块一直在使用

4.3 weak_ptr

• 在 C++ 中还有一个类与 shared_ptr 模板有关，那就是 weak_ptr。weak_ptr 可包含由 shared_ptr 管理的资源的引用。weak_ptr 不拥有这个资源，所以不能阻止 shared_ptr 释放资源
• weak_ptr 销毁时 (例如离开作用域时) 不会销毁它指向的资源：然而，它可用于判断资源是否已经被关联的 shared_ptr 释放了。weak_ptr 的构造函数要求将一个 shared_ptr 或另一个 weak_ptr 作为参数
• 为了访问 weak_ptr 中保存的指针，需要将 weak_ptr 转换为 shared_ptr 有两种方法
  • 使用 weak_ptr 实例的 lock() 方法，这个方法返回一个 shared_ptr。如果同时释放了与 weak_ptr 关联的 shared_ptr，返回的 shared_ptr 是 nullptr
  • 创建一个新的 shared_ptr 实例，将 weak_ptr 作为 shared_ptr 构造函数的参数。如果释放了与 weak_ptr 关联的 shared_ptr，将抛出 std:bad_weak_ptr 异常

#include <memory>
#include <iostream>using namespace std;class Simple {
public:Simple() { cout << "Simple constructor called!" << endl; }~Simple() { cout << "Simple destructor called!" << endl; }
};void useResource(weak_ptr<Simple> &weakSimple) {auto resource = weakSimple.lock();if (resource) {cout << "Resource still alive." << endl;} else {cout << "Resource has been freed!" << endl;}
}int main() {auto sharedSimple = make_shared<Simple>();weak_ptr<Simple> weakSimple(sharedSimple);// Try to use the weak_ptr.useResource(weakSimple);// Reset the shared_ptr.// Since there is only 1 shared_ptr to the Simple resource, this will// free the resource, even though there is still a weak_ptr alive.sharedSimple.reset();// Try to use the weak_ptr a second time.useResource(weakSimple);return 0;
}

5. 常见的内存陷阱

5.1 分配不足的字符串

• 与 C 风格字符串相关的最常见问题是分配不足
  • 大多数情况下，都是因为没有分配尾部的 ‘\0’ 终止字符
  • 当假设某个固定的最大大小时，也会发生字符串分配不足的情况。基本的内置 C 风格字符串函数不会针对固定的大小操作，而是有多少写多少，如果超出字符串的末尾，就写入未分配的内存
• 以下代码演示了字符串分配不足的情况

  char buffer[1024] = {0};
  while (true) {// getMoreData() 函数返回一个指向动态分配内存的指针char *nextChunk = getMoreData();if (nextChunk == nullptr) {break;} else {// 把第二个参数的 C 风格字符串连接到第一个参数的 C 风格字符串的尾部strcat(buffer, nextChunk);delete[] nextChunk;}
  }
  

• 解决上述字符串分配不足问题的方法
  • 1、使用 C++ 风格的字符串，可自动处理与连接字符串关联的内存
  • 2、不要将缓冲区分配为全局变量或分配在堆栈上，而是分配在堆上
  • 3、创建另一个版本的 getMoreData()，这个版本接收一个最大计数值 (包括 0 字符)，返回的字符数不多于这个值，然后跟踪剩余的空间数以及缓冲区中当前的位置

5.2 访问内存越界

• 指针只不过是一个内存地址，因此指针可能指向内存中的任意位置。例如，考虑一个 C 风格的字符串，它不小心丢失了 ‘\0’ 终止字符。下面这个函数试图将字符串填满 m 字符，但实际上可能会继续在字符串后面填充 m

  void fillWithM(char *inStr) {int i = 0;while (inStr[i] != '\0') {inStr[i] = 'm';i++;}
  }
  

• 如果把不正确的终止字符串传入这个函数，那么内存的重要部分被改写而导致程序崩溃只是时间问题，写入数组尾部后面的内存产生的 bug 称为缓冲区溢出错误

避免使用旧的 C 风格字符串和数组，它们没有提供任何保护，而要改用像 C++ string 和 vector 这样安全的现代结构，它们能够自动管理内存

5.3 内存泄漏

• 分配了内存，但没有释放，就会发生内存泄漏。起初，这听上去好像是粗心编程的结果，应该很容易避免。毕竟，如果在编写的每个类中，每个 new 都对应一个 deete，那么应该不会出现内存泄漏。实际上并不总是如此
  • 在下面的代码中，Simple 类编写正确，释放了每一处分配的内存。当调用 doSomething() 函数时，outSimplePtr 指针修改为指向另一个 Simple 对象，但是没有释放原来的 Simple 对象。为了演示内存泄漏，doSomething() 函数故意没有删除旧的对象。一旦失去对象的指针，就几乎不可能删除它了

  class Simple {
  public:Simple() {mIntPtr = new int();}  ~Simple() {delete mIntPtr;}void setValue(int value) {*mIntPtr = value;}
  private:int *mIntPtr;
  };void doSomething(Simple *&outSimplePtr) {outSimplePtr = new Simple();
  }int main() {Simple *simplePtr = new Simple();doSomething(simplePtr);// 只删除第二个对象，没有删除旧的对象delete simplePtr;return 0;
  }
  

以上只是演示内存泄漏，实际应使 mIntPtr 和 simplePtr 成为 unique_ptr，使 outSimplePtr 成为 unique_ptr 的引用