C++内存管理解析（初学者入门学习）

tang_shou

807人浏览 · 2025-11-07 20:54:45

tang_shou · 2025-11-07 20:54:45 发布

1. C/C++内存分布

C/C++中内存区域划分：

静态变量都是放在数据段，也可以叫静态区，静态区还可以划分为“初始化区”和“未初始化区”；“代码段”也叫“常量区”

前三个变量的生命周期，在整个程序运行之间都在，区别就在于前两个在程序运行到main之前就初始化，而第三个要走到那一行才初始化

局部变量存在栈上

char2是一个栈上的数组，数组名是首元素的地址，所以*char2相当于解引用数组的首个元素，数组在栈上，所以首元素也在栈上

指针变量是存在栈上的，但是*pChar3指向的是字符串，是一个常量，所以应该在常量区，也就是代码段

而ptr1依旧是局部变量的指针，还是在栈上，而它指向的内容才是用malloc划分出来的，所以是堆

局部的静态变量。生命周期是全局，但是只在其声明那一行才开始构造和初始化

局部变量先析构，静态对象和全局对象后析构，而后定义的先析构

2. C语言中动态内存管理方式：malloc/calloc/realloc/free

malloc/calloc/realloc 的区别：

malloc

void* malloc (size_t size) //size 为开辟字节数

这个函数向内存申请一块连续可用的空间,并返回指向这块空间的指针。

如果开辟成功,则返回一个指向开辟好空间的指针。
如果开辟失败,则返回一个NULL指针,因此malloc的返回值一定要做检查。
返回值的类型是void*,所以malloc函数并不知道开辟空间的类型,具体在使用的时候使用者自己来决定。
如果参数 size 为0,malloc的行为是标准是未定义的,取决于编译器。

calloc

void* calloc (size_t num, size_t size);

函数的功能是为 num个大小为size的元素开辟一块空间,并且把空间的每个字节初始化为0。

与函数 malloc的区别只在于calloc会在返回地址之前把申请的空间的每个字节初始化为全0。

realloc

realloc函数的出现让动态内存管理更加灵活。
有时会我们发现过去申请的空间太小了,有时候我们又会觉得申请的空间过大了,那为了合理的时候内存,

我们一定会对内存的大小做灵活的调整。那realloc函数就可以做到对动态开辟内存大小的调整。函数原型如下:

void* realloc (void* ptr, size_t size);

ptr 是要调整的内存地址
size 调整之后新大小

同时，realloc 还可以实现 malloc 的作用：

int *p = realloc(NULL, 40);//等价于 malloc(40)

realloc 的使用注意事项：

1.当地址指向的内存空间之后有足够的内存空间可以追加时，在原来内存空间基础上追加空间，并返回旧地址；

2.当后续内存空间不够追加时，realloc 会重新找一个新的内存区域，一次性开辟一个新的足够大小的空间，并将原来空间上的内容拷贝过去，返回新的空间的地址，然后将旧空间释放掉。

3.当需要 realloc 函数开辟的空间过大时，realloc 会返回空指针，而此时如果拿原指针接收会导致原指针指向区域丢失，所以一般会用一个新的指针变量接收返回值，检测是否开辟失败，确认开辟成功过后再将返回值赋给原指针。（如下代码）

4.当需要用 realloc 缩小动态内存块时，原内存块中被缩小部分的数据将会丢失。因此，在缩小内存前，确保不再需要那些数据，或者已经将其复制到其他地方。

int* ptr = realloc(p, 40);
if (ptr != NULL)
{
        p = ptr;
}

3. C++内存管理方式

Q:既然C语言的内存管理方式C++也可以用，那么C++为什么还要再使用一套新的内存管理方式呢“？

C语言内存管理方式在C++中可以继续使用，但有些地方就无能为力，而且使用起来比较麻烦，因此C++又提出了自己的内存管理方式：通过new和delete操作符进行动态内存管理。

new/delete操作内置类型

void Test()
{
    // 动态申请一个 int 类型的空间（未初始化）
    int* ptr4 = new int;
    
    // 动态申请一个 int 类型的空间并初始化为 10
    int* ptr5 = new int(10);
    
    // 动态申请 10 个 int 类型的空间（未初始化）
    int* ptr6 = new int[10];
    
    // 错误写法：不能这样初始化数组
    // int* ptr7 = new int[10](10); // 编译错误
    
    // 释放内存
    delete ptr4;
    delete ptr5;
    delete[] ptr6;
}

使用须知：

对于内置类型，new/delete和 malloc/free 效果是一样的，对于自定义类型，效果就不一样。

单个元素使用 new 和 delete，数组使用 new[] 和 delete[]

3.2 new和delete操作自定义类型

class A
{
public:
    A(int a = 0) : _a(a)
    {
        cout << "A():" << this << endl;
    }
    
    ~A()
    {
        cout << "~A():" << this << endl;
    }
    
private:
    int _a;
};

int main()
{
    // malloc/free 不会调用构造函数和析构函数
    A* p1 = (A*)malloc(sizeof(A)); // 只申请空间
    free(p1); // 只释放空间
    
    // new/delete 会自动调用构造函数和析构函数
    A* p2 = new A(1); // 申请空间 + 调用构造函数
    delete p2; // 调用析构函数 + 释放空间
    
    // 数组操作
    A* p5 = (A*)malloc(sizeof(A) * 10); // 只申请空间
    free(p5); // 只释放空间
    
    A* p6 = new A[10]; // 申请空间 + 调用10次构造函数
    delete[] p6; // 调用10次析构函数 + 释放空间
    
    return 0;
}

区别：

new 会调用构造函数，delete 会调用析构函数
malloc 和 free 只负责内存分配和释放
对于自定义类型，必须使用 new/delete

3.3 new/delete

现在我们用创建链表节点来看看C语言和C++内存管理方式具体有什么不同

#include <iostream>
using namespace std;

struct ListNode
{
    int _val;
    struct ListNode* _next;
    struct ListNode* _prev;
};

typedef struct ListNode ListNode_t;

ListNode_t* CreatListNode(int val)
{
    ListNode_t* node_c = (ListNode_t*)malloc(sizeof(ListNode_t));
    node_c->_val = val;
    node_c->_next = NULL;
    node_c->_prev = NULL;
    return node_c;
}

struct ListNode_CPP
{
    int _val;
    struct ListNode_CPP* _next; //兼容C struct 的用法
    ListNode_CPP* _prev; //CPP中，struct已经可以认为是类，和class一样，区别是默认访问限定符

    ListNode_CPP(int val = 0)
        : _val(val)
        , _next(nullptr)
        , _prev(nullptr)
    {
    }
};
int main()
{
    // C 语言方式：需要单独初始化
    ListNode_t* node1 = CreatListNode(1);

    // C++ 方式：定义即初始化
    ListNode_CPP* node2= new ListNode_CPP; // 使用默认参数
    ListNode_CPP* node3 = new ListNode_CPP(5); // 使用指定参数

    // 释放内存
    delete node2;
    delete node3;

    return 0;
}

使用不同：

在C语言中，每创建一个对象，都要再手动调用一个自定义的函数来进行初始化，但是在c++中，有了构造函数的概念，可以将构造函数封装进结构体中，在定义的时候就可以直接初始化，比C语言方便快捷不少。

总结：

C++的使用诠释了面向对象的思想，定义即是初始化，使代码的封装更加完整简洁，使用更加方便，不需要单独的函数来初始化，可以自动调用构造/析构函数，更加安全

4. operator new与operator delete函数

基本概念

new和delete是用户进行动态内存申请和释放的操作符，operator new 和operator delete是系统提供的全局函数。
new在底层调用operator new全局函数来申请空间，delete在底层通过operator delete全局函数来释放空间。
operator new 的用法和 malloc 一模一样，operator delete 和 free 的用法一模一样。
```
class A
{
public:
        A(){cout << "A()" << endl;}
        ~A(){cout << "~A()" << endl;}
private:
        // ...
};

int main()
{
        // 下面两个都不会调用构造函数
        A* p1 = (A*)malloc(sizeof(A));
        A* p3 = (A*)operator new(sizeof(A));
        return 0;
}
```
由于C语言和C++的性质不一样，一个是面向过程，一个是面向对象，所以在申请内存失败时，其处理的方式也不一样
```
  void* p4 = malloc(2 * 1024 * 1024 * 1024);
  
  void* p5 = operator new(2* 1024 * 1024 * 1024);
```
用malloc申请内存失败是返回的是0 ，而用operator申请失败时，会弹出异常，程序报错。

operator new 实际也是通过malloc来申请空间，如果malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常。operator delete 最终是通过free来释放空间的

5. new和delete的实现原理

operator new = malloc + 失败抛异常实现

new = operator new + 构造函数

new 对比 malloc ：1、调用构造函数初始化。2、失败了抛异常

delete 对比 free ：1.多一个调用析构函数清理。（一般free不会失败，因为free是释放空间，除非你释放空间的位置不对，一般释放空间失败会导致进程直接终止）

5.1 内置类型

如果申请的是内置类型的空间，new和malloc，delete和free基本类似，不同的地方是：

new/delete申请和释放的是单个元素的空间，new[]和delete[]申请的是连续空间，而且new在申请空间失败时会抛异常，malloc会返回NULL。

5.2 自定义类型

new 的原理
调用 operator new 函数申请空间
在申请的空间上执行构造函数