[C++] 深度剖析C

文章目录

• 内存分布
• • 内存分布图解
  • 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新特性与知识补充

              

              内存分布

              内存分布图解

              

              1. 栈又叫堆栈–非静态局部变量/函数参数/返回值等等，栈是向下增长的。
              2. 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口

                 创建共享共享内存，做进程间通信。

              3. 堆用于程序运行时动态内存分配，堆是可以上增长的。
              4. 数据段–存储全局数据和静态数据。
              5. 代码段–可执行的代码/只读常量

              

              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相似
                    • 自定义类型：
                      1. 调用operator new函数申请空间
                      2. 在申请的空间上执行构造函数，完成对象的构造

                      源码如下

                      /*
                      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基本类似
                        • 自定义类型：
                          1. 在空间上执行析构函数，完成对象中资源的清理工作
                          2. 调用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]的原理

                            1. 调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对

                               象空间的申请

                            2. 在申请的空间上执行N次构造函数

                            delete[]的原理

                            1. 在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理
                            2. 调用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