[C++] 深度剖析C

07-21 1519阅读

文章目录

内存分布
- 内存分布图解
- C语言中动态内存管理方式
- - malloc:
  - calloc
  - realloc
  - C++内存管理方式
  - - 内置类型
    - **自定义类型**
    - operator new & operator delete
    - - operator new & operator delete函数
      - operator new
        operator delete
        **new T[N]** 与**delete[]**
        **定位new表达式(placement-new)**
        如何使用
        注意事项
        malloc/free和new/delete的区别
        类和对象三部曲：
        [C++] 轻熟类和对象
        [C++] 由浅入深理解面向对象思想的组成模块
        类和对象：C++11新特性与知识补充
        
        内存分布
        
        内存分布图解
        
        
        
        栈又叫堆栈–非静态局部变量/函数参数/返回值等等，栈是向下增长的。
        内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口
        创建共享共享内存，做进程间通信。
        堆用于程序运行时动态内存分配，堆是可以上增长的。
        数据段–存储全局数据和静态数据。
        代码段–可执行的代码/只读常量
        
        C语言中动态内存管理方式
        
        malloc:
        
        void* malloc(size_t size);
        功能：malloc函数用于在堆上分配一块连续的内存空间。它接受一个参数，即所需内存的大小（以字节为单位），并返回指向这块内存的指针。
        初始化：malloc不会对分配的内存进行初始化，内存中的内容是未定义的，可能是之前的值或者全零，具体取决于操作系统。
        使用场景：当不需要初始化内存或者特定初始化时使用。
        calloc
        
        void* calloc(size_t num, size_t size);
        功能：calloc也用于在堆上分配内存，但它接受两个参数，分别是要分配的元素数量和每个元素的大小（以字节为单位）。calloc会确保分配的内存区域中的每个字节都被初始化为零。
        初始化：与malloc不同，calloc会将分配的内存全部初始化为零，这使得它适合用于数组或结构体等需要初始化为默认值的情况。
        使用场景：当需要一个清零的内存块时使用，比如初始化数组。
        realloc
        
        void* realloc(void* ptr, size_t size);
        功能：realloc用于调整先前通过malloc、calloc或realloc分配的内存块的大小。它接受两个参数，第一个是之前分配的内存的指针，第二个是新的大小（可以比原来大也可以比原来小）。
        初始化：realloc不涉及初始化新分配的内存部分，如果扩大了内存块，新增的部分通常也是未定义的值。
        使用场景：当原先分配的内存大小不再满足需求，需要扩大或减小内存空间时使用。需要注意的是，如果减小内存空间，超出新大小的部分数据会被截断。
        
        C++内存管理方式
        
        内置类型
        
        // 动态申请一个int类型的空间 int* ptr4 = new int; // 动态申请一个int类型的空间并初始化为10 int* ptr5 = new int(10); // 动态申请10个int类型的空间 int* ptr6 = new int[10]; delete ptr4; delete ptr5; delete[] ptr6; // 其他方式 int* p3 = new int(0); int* p4 = new int[10]{ 0 }; int* p5 = new int[10]{1,2,3,4,5}; // 未初始化的用0补齐
        
        
        
        注意：申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用new[]和delete[]。
        
        自定义类型
        
        A* p1 = (A*)malloc(sizeof(A)); // C A* p2 = new A(1); // C++ A* p1 = new A(1); A* p2 = new A(2,2); // 隐式类型 A aa1(1, 1); A aa2(2, 2); A aa3(3, 3); A* p3 = new A[3]{aa1, aa2, aa3}; A* p4 = new A[3]{ A(1,1), A(2,2), A(3,3)}; // 匿名函数 //A aa1 = { 1, 1 }; A* p5 = new A[3]{ {1,1}, {2,2}, {3,3} };
        
        C++中推荐使用new和delete进行内存管理，使用这二者进行内存管理的特点为**“除了开空间还会调用构造函数和析构函数”（原理下章会提及）**
        
        operator new & operator delete
        
        operator new & operator delete函数
        
        operator new
        
        原理：
        
        **内置类型：**与malloc相似
        自定义类型：
        调用operator new函数申请空间
        在申请的空间上执行构造函数，完成对象的构造
        源码如下
        
        /* operator new：该函数实际通过malloc来申请空间，当malloc申请空间成功时直接返回；申请空间失败，尝试执行空间不足应对措施，如果改应对措施用户设置了，则继续申请，否则抛异常。 */ void* __CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc) { // try to allocate size bytes void* p; while ((p = malloc(size)) == 0) // 通过malloc扩容 if (_callnewh(size) == 0) { // report no memory // 如果申请内存失败了，这里会抛出bad_alloc 类型异常 static const std::bad_alloc nomem; _RAISE(nomem); } return (p);// 返回分配的内存指针 }
        
        通过分析源码可得出：
        
        在底层会调用 **malloc** 分配内存：函数内部有一个 while 循环，通过 malloc 分配指定大小的内存。
        **会自动抛异常：**当 malloc 返回 nullptr，则调用 _callnewh 尝试处理内存不足的情况，若仍然无法分配内存，则抛出 std::bad_alloc 异常。
        在语法层面上会调用构造函数：new 操作符分配内存后，会在分配的内存上调用构造函数，完成对象的初始化。
        operator delete
        
        原理：
        
        **内置类型：**与free基本类似
        自定义类型：
        在空间上执行析构函数，完成对象中资源的清理工作
        调用operator delete函数释放对象的空间
        源码如下：
        
        /* operator delete: 该函数最终是通过free来释放空间的 */ void operator delete(void* pUserData) { _CrtMemBlockHeader* pHead; RTCCALLBACK(_RTC_Free_hook, (pUserData, 0)); if (pUserData == NULL) return; _mlock(_HEAP_LOCK); /* block other threads */ __TRY /* 获取指针指向内存块的头信息 */ pHead = pHdr(pUserData); /* verify block type */ _ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse)); _free_dbg(pUserData, pHead->nBlockUse); // 使用_free_dbg进行内存的释放 __FINALLY _munlock(_HEAP_LOCK); /* release other threads */ __END_TRY_FINALLY return; } /* free的实现 */ #define free(p) _free_dbg(p, _NORMAL_BLOCK)
        
        源码分析：
        
        #define free(p) _free_dbg(p, _NORMAL_BLOCK)我们可以发现，free的底层其实是一个宏，最终还是使用 _free_dbg(p, _NORMAL_BLOCK)进行内存释放。
        通过第一点分析可得，delete的底层也是通过free，或者说_free_dbg(p, _NORMAL_BLOCK)进行内存的释放
        在语法层面上调用析构函数：在释放内存之前调用对象的析构函数，以确保对象持有的资源（如动态分配的内存、打开的文件等）得到正确释放。
        编译器在处理 delete obj; 这行代码时会生成以下等效的代码：
        
        if (obj != nullptr) { obj->~A(); // 显式调用析构函数 operator delete(obj); // 调用 operator delete 释放内存 }
        
        new T[N] 与delete[]
        
        new T[N]的原理
        
        调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对
        象空间的申请
        在申请的空间上执行N次构造函数
        delete[]的原理
        
        在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理
        调用operator delete[]释放空间，实际在operator delete[]中调用operator delete来释
        放空间
        
        定位new表达式(placement-new)
        
        定位new表达式语法：void* operator new(size_t, void* place) noexcept { return place; }
        
        定位new表达式（Placement New Expression），或简称placement new，是C++中一种特殊的内存分配式，它允许你在已经分配好的内存区域内构造对象。与标准的new操作符不同，定位new不负责内存的分配，而是直接在你指定的内存地址上调用对象的构造函数。这对于实现内存池、重复利用已分配的内存块、在特定内存位置（如共享内存）创建对象等场景非常有用。
        定位 new 表达式允许我们在预分配的内存上构造对象，并手动管理对象的生命周期，包括调用析构函数和释放内存。这样可以更好地控制内存分配和释放过程，避免内存泄漏和资源未释放的问题。
        如何使用
        
        举例
        
        #include #include // for malloc and free using namespace std; class MyClass { public: MyClass(int value) : value(value) { cout cout // Step 1: Allocate raw memory using malloc size_t numObjects = 3; void* rawMemory = malloc(numObjects * sizeof(MyClass)); if (!rawMemory) { cerr new (objects + i) MyClass(i * 10); // Construct MyClass objects with values 0, 10, 20 } // Step 3: Use the objects (this step is trivial in this example) // Step 4: Manually call destructors for each object for (size_t i = 0; i