《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; // 等价于上面两行代码
    

《C++高级编程》读书笔记(七:内存管理)_第1张图片

  • 指针既可在堆栈中,也可在堆中
    • 下面的代码首先声明一个指向整数指针的指针变量 handle
    • 然后,动态分配足够的内存来保存一个指向整数的指针,并将指向这个新内存的指针保存在 handle 中
    • 接下来,将另一块足以保存整数的动态内存的指针保存在 * handle 的内存位置
    int* *handle = nullptr;
    handle = new int*;
    *handle = new int;
    
  • 下图展示了这个两级指针,其中一个指针保存在堆栈中 (handle),另一个指针保存在堆中 (*handle)

《C++高级编程》读书笔记(七:内存管理)_第2张图片

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() 和 free() 函数,只使用 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];
    

《C++高级编程》读书笔记(七:内存管理)_第3张图片

  • 在堆上声明数组没什么不同,只是需要通过一个指针引用数组的位置。下面的代码为包含 5 个 int 型数字的数组分配内存,并将指向这块内存的指针保存在变量 myArrayPtr 中
  • 堆中的数组和堆栈中的数组类似,只是位置不同而已。myArrayPtr 变量指向数组的第 0 个元素。把数组放在堆中的好处在于可在运行时通过动态内存指定数组大小
    int *myArrayPtr = new int[5];
    delete[] myArrayPtr; // 对 new[] 的每次调用都应与 delete[] 调用配对,以清理内存
    myArrayPtr = nullptr;
    

《C++高级编程》读书笔记(七:内存管理)_第4张图片

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

1.3.2 对象的数组
  • 对象的数组和简单类型的数组没有区别。通过 new[N] 分配 N 个对象的数组时,实际上分配了 N 个连续的内存块,每一块足以容纳单个对象
  • 使用 new[] 时,每个对象的无参构造函数 (= default) 会自动调用。这样,通过 new[] 分配对象数组时,会返回一个指向数组的指针,这个数组中的所有对象都被初始化了
    class Simple
    {
        public:
            Simple() {}
            ~Simple() {}
    };
    // 如果要分配包含 4 个 Simple 对象的数组,那么 Simple 构造函数会被调用 4 次
    Simple *mySimpleArray = new Simple[4];
    

《C++高级编程》读书笔记(七:内存管理)_第5张图片

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

《C++高级编程》读书笔记(七:内存管理)_第6张图片

  • 2. 多维堆数组
    • 如果需要在运行时确定多维数组的维数,可以使用堆数组。正如动态分配的一维数组是通过指针访问一样,动态分配的多维数组也通过指针访问。唯一的区别在于,在二维数组中,需要使用指针的指针:在 N 维数组中,需要使用 N 级指针
    // 编译器并不自动分配子数组的内存。可像分配一维堆数组那样分配第一个维度的数组
    // 但是必须显式地分配每一个子数组。下面的函数正确分配了二维数组的内存
    char** allocateCharacterBoard(size_t xDimension, size_t yDimension) {
        char** myArray = new char*[xDimension]; // Allocate first dimension
        
        for (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++高级编程》读书笔记(七:内存管理)_第7张图片

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

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

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 所管理的对象
    • 使用智能指针时,需要添加 头文件

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 
#include 

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 的引用

你可能感兴趣的:(C++进阶学习笔记,c++,算法,开发语言,学习,笔记)