【C++】C/C++内存管理(超详细解析，小白必看系列）

1 C/C++内存分布

1.1 内存分布介绍

在C/C++程序中，内存分布通常分为以下几个主要部分：

这种内存布局有助于程序的高效运行和内存管理。

1.2 代码介绍

int globalVar = 1;
static int staticGlobalVar = 1;
void Test()
{
 static int staticVar = 1;
 int localVar = 1;
 int num1[10] = { 1, 2, 3, 4 };
 char char2[] = "abcd";
 const char* pChar3 = "abcd";
 int* ptr1 = (int*)malloc(sizeof(int) * 4);
 int* ptr2 = (int*)calloc(4, sizeof(int));
 int* ptr3 = (int*)realloc(ptr2, sizeof(int) * 4);
 free(ptr1);
 free(ptr3);
}

2. C语言中动态内存管理方式：

在 C 语言中，动态内存管理是通过几个标准库函数来实现的，这些函数主要包括 malloc、calloc、realloc 和 free。这些函数都在 <stdlib.h> 头文件中定义。以下是它们的主要功能和用法：

1. malloc 函数：

   • 用于在堆区分配一块指定大小的内存空间。
   • 语法：void* malloc(size_t size);
   • 返回一个指向分配内存的指针，如果分配失败则返回 NULL。
   • 示例：

     int *ptr = (int*)malloc(10 * sizeof(int));
     if (ptr == NULL) {
         // 处理内存分配失败
     }
     

2. calloc 函数：

   • 用于在内存中分配多个元素，并将每个元素初始化为零。
   • 语法：void* calloc(size_t num, size_t size);
   • 返回一个指向分配内存的指针，如果分配失败则返回 NULL。
   • 示例：

     int *ptr = (int*)calloc(10, sizeof(int));
     if (ptr == NULL) {
         // 处理内存分配失败
     }
     

3. realloc 函数：

   • 用于重新分配内存，把内存块扩展到新的大小。
   • 语法：void* realloc(void* ptr, size_t new_size);
   • 返回一个指向重新分配内存的指针，如果分配失败则返回 NULL。
   • 示例：

     ptr = (int*)realloc(ptr, 20 * sizeof(int));
     if (ptr == NULL) {
         // 处理内存分配失败
     }
     

4. free 函数：

   • 用于释放先前通过 malloc、calloc 或 realloc 分配的内存。
   • 语法：void free(void* ptr);
   • 示例：

     free(ptr);
     ptr = NULL; // 避免悬空指针
     

3. C++内存管理方式

3.1 new/delete操作内置类型

在 C++ 中，new 和 delete 操作符用于动态内存管理，特别是内置类型的内存分配和释放。以下是它们的基本用法和注意事项：

使用 new 操作符

1. 分配单个内置类型的内存：

   int* ptr = new int; // 分配一个 int 类型的内存
   *ptr = 10; // 初始化
   

2. 分配并初始化单个内置类型的内存：

   int* ptr = new int(10); // 分配并初始化为 10
   

3. 分配数组内置类型的内存：

   int* arr = new int[10]; // 分配一个包含 10 个 int 类型元素的数组
   

使用 delete 操作符

1. 释放单个内置类型的内存：

   delete ptr; // 释放单个 int 类型的内存
   

2. 释放数组内置类型的内存：

   delete[] arr; // 释放数组内存
   

注意事项

• 异常处理：new 操作符在内存分配失败时会抛出 std::bad_alloc 异常，而 malloc 则返回 NULL。因此，使用 new 时可以通过 try-catch 块来处理异常。

  try {
      int* ptr = new int[1000000000]; // 可能会失败
  } catch (std::bad_alloc& e) {
      std::cerr << "Memory allocation failed: " << e.what() << std::endl;
  }
  

• 避免内存泄漏：确保每个 new 对应一个 delete，每个 new[] 对应一个 delete[]，以避免内存泄漏。

• 初始化：使用 new 分配的内存未初始化（除非显式初始化），而 new int(10) 这样的语法可以直接初始化内存。

3.2 new/delete操作内置类型

在 C++ 中，new 和 delete 操作符不仅可以用于内置类型，还可以用于自定义类型（类）。以下是如何使用 new 和 delete 来管理自定义类型的内存：

使用 new 操作符

1. 分配单个自定义类型对象的内存：

   class MyClass {
   public:
       MyClass(int value) : data(value) {}
       ~MyClass() {}
   private:
       int data;
   };
   
   MyClass* obj = new MyClass(10); // 调用构造函数
   

2. 分配数组自定义类型对象的内存：

   MyClass* objArray = new MyClass[3]; // 调用默认构造函数
   

使用 delete 操作符

1. 释放单个自定义类型对象的内存：

   delete obj; // 调用析构函数
   

2. 释放数组自定义类型对象的内存：

   delete[] objArray; // 调用每个对象的析构函数
   

注意事项

• 构造函数和析构函数：使用 new 分配内存时，会自动调用构造函数进行初始化；使用 delete 释放内存时，会自动调用析构函数进行清理。
• 数组分配：当使用 new[] 分配数组时，必须使用 delete[] 释放内存，以确保每个对象的析构函数都被正确调用。
• 异常处理：new 操作符在分配失败时会抛出 std::bad_alloc 异常，可以使用 try-catch 块来处理。

示例代码

#include <iostream>

class MyClass {
public:
    MyClass(int value = 0) : data(value) {
        std::cout << "Constructor called with value: " << data << std::endl;
    }
    ~MyClass() {
        std::cout << "Destructor called for value: " << data << std::endl;
    }
private:
    int data;
};

int main() {
    // 分配单个对象
    MyClass* obj = new MyClass(10);
    delete obj;

    // 分配对象数组
    MyClass* objArray = new MyClass[3];
    delete[] objArray;

    return 0;
}

4. operator new与operator delete函数

在 C++ 中，new和delete是用户进行动态内存申请和释放的操作符，operator new 和operator delete是系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层通过operator delete全局函数来释放空间。

operator new 函数

1. 基本用法：

   /*
   operator new：该函数实际通过malloc来申请空间，当malloc申请空间成功时直接返回；申请空间失败，尝试执行空               间不足应对措施，如果改应对措施用户设置了，则继续申请，否则抛异常。
   */
   void*__CRTDECLoperatornew(size_tsize) _THROW1(_STDbad_alloc)
   {// try to allocate size bytes
       void*p;
       while ((p=malloc(size)) ==0)
        if (_callnewh(size) ==0)
        {
            // report no memory
            // 如果申请内存失败了，这里会抛出bad_alloc 类型异常                             
            staticconststd::bad_allocnomem;
            _RAISE(nomem);
        }
       return (p);
   }
   

   • 该函数分配一块大小为 size 字节的内存，并返回一个指向这块内存的指针。
   • 如果分配失败，默认情况下会抛出 std::bad_alloc 异常。

2. 示例：

   void* ptr = operator new(sizeof(int) * 10); // 分配 10 个 int 的内存
   

3. 重载：

   • 可以重载 operator new 以自定义内存分配行为。例如：

     void* MyClass::operator new(size_t size) {
         void* p = ::operator new(size);
         // 自定义初始化或日志记录
         return p;
     }
     

operator delete 函数

1. 基本用法：

   void operator delete(void *pUserData)
   {
        _CrtMemBlockHeader * pHead;
        RTCCALLBACK(_RTC_Free_hook, (pUserData, 0));
        if (pUserData == NULL)
            return;
        _mlock(_HEAP_LOCK);  /* block other threads */
        __TRY
            /* get a pointer to memory block header */
            pHead = pHdr(pUserData);
             /* verify block type */
            _ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));
            _free_dbg( pUserData, pHead->nBlockUse );
        __FINALLY
            _munlock(_HEAP_LOCK);  /* release other threads */
        __END_TRY_FINALLY
        return;
   }
   /*
   free的实现
   */
   #define   free(p)               _free_dbg(p, _NORMAL_BLOCK)
   

   • 该函数释放由 operator new 分配的内存。
   • pUserData 是指向要释放的内存的指针。

2. 示例：

   operator delete(ptr); // 释放内存
   

3. 重载：

   • 可以重载 operator delete 以自定义内存释放行为。例如：

     void MyClass::operator delete(void* ptr) {
         // 自定义清理或日志记录
         ::operator delete(ptr);
     }
     

operator new[] 和 operator delete[]

• 数组分配和释放：

  void* operator new;
  void operator delete;
  

  • 这些函数用于分配和释放数组内存，与 operator new 和 operator delete 类似，但用于数组。

示例代码

#include <iostream>
#include <new> // 包含 operator new 和 operator delete 的声明

class MyClass {
public:
    MyClass() { std::cout << "Constructor called\n"; }
    ~MyClass() { std::cout << "Destructor called\n"; }

    void* operator new(size_t size) {
        std::cout << "Custom operator new\n";
        return ::operator new(size);
    }

    void operator delete(void* ptr) {
        std::cout << "Custom operator delete\n";
        ::operator delete(ptr);
    }
};

int main() {
    MyClass* obj = new MyClass(); // 调用自定义的 operator new
    delete obj; // 调用自定义的 operator delete

    return 0;
}

5. new和delete的实现原理

5.1 内置类型

#include <iostream>
#include <new> // 包含 operator new 和 operator delete 的声明

class MyClass {
public:
    MyClass(int value) : data(value) {
        std::cout << "Constructor called with value: " << data << std::endl;
    }
    ~MyClass() {
        std::cout << "Destructor called for value: " << data << std::endl;
    }
private:
    int data;
};

int main() {
    // 使用 new 分配单个对象
    MyClass* obj = new MyClass(10); // 调用构造函数
    delete obj; // 调用析构函数并释放内存

    // 使用 new 分配对象数组
    MyClass* objArray = new MyClass[3]; // 调用默认构造函数
    delete[] objArray; // 调用析构函数并释放数组内存

    return 0;
}

void* operator new(size_t size, void* ptr) noexcept;

#include <iostream>
#include <new> // 包含 placement new 的声明

class MyClass {
public:
    MyClass(int value) : data(value) {
        std::cout << "Constructor called with value: " << data << std::endl;
    }
    ~MyClass() {
        std::cout << "Destructor called for value: " << data << std::endl;
    }
private:
    int data;
};

int main() {
    // 预先分配内存
    char buffer[sizeof(MyClass)];

    // 使用定位 new 在已有内存上构造对象
    MyClass* obj = new (buffer) MyClass(42);

    // 调用对象的方法
    obj->~MyClass(); // 显式调用析构函数

    return 0;
}