一文讲懂C/C++动态内存管理

当我们在使用数组的时候必须指定数组的元素个数，此时也就确定了数组空间的大小，这时会存在以下几个缺点：输入元素过多会导致数组越界，输入元素过小带来空间的浪费，且数组的大小在我们使用的时候不能够动态的去调整。而动态内存分配(Dynamic Memory Allocation )能在程序运行期间动态的分配或者释放内存空间，这样我们对内存的使用便可以做到按需分配空间。那么接下来我们一起来研究一下C/C++中的动态内存管理吧！

[一. C语言动态内存管理](#一. C语言动态内存管理)

[1.malloc() 函数](#1.malloc() 函数)

[2. calloc() 函数](#2. calloc() 函数)

[3. realloc() 函数](#3. realloc() 函数)

[二 . C++动态内存管理](#二 . C++动态内存管理)

[1. new delete 操作符内置类型的动态内存管理](#1. new delete 操作符内置类型的动态内存管理)

[2. new delete 操作符自定义类型的动态内存管理](#2. new delete 操作符自定义类型的动态内存管理)

[3. malloc/free和new/delete的区别](#3. malloc/free和new/delete的区别)

一. C语言动态内存管理

1.malloc() 函数

malloc() 函数是C语言提供的一个动态内存开辟函数，原理是向内存申请一块连续可用的空间，并返回指向这块空间的指针。

#include<stdlib>//malloc()头文件
//malloc
void* malloc(size_t size)
//size_t 无符号类型
//size:申请的内存大小，单位字节
//void* 需利用强制类型转成所需要的指针类型

我们现在利用 malloc( ) 来创建一个数组,也就是申请了4个int类型大小的空间，共16个字节，p指向这片空间的所在位置。

int* p = (int*)malloc(4*sizeof(int));
if(p == NULL)
{
    perror("malloc failed");
}

需要注意的是， malloc() 动态内存申请成功，则返回一个指向这片空间的指针，如果申请失败，则返回一个NULL指针。因此，malloc() 返回值可能是NULL指针，使用时需要检查；同时 malloc() 申请的空间没有被初始化。

2. calloc() 函数

calloc() 函数功能与malloc() 一样，二者的区别在于 calloc() 会对申请的空间初始化为0，此外它们请求内存的大小方式不同。

#include<stdlib>//calloc()头文件
//calloc
void* calloc(size_t size,size_t num)
//num 元素个数
//size_t 无符号类型
//size:申请的内存大小，单位字节
//void* 需利用强制类型转成所需要的指针类型

空间申请成功返回该空间的起始地址，失败返回NULL指针。下面的代码来验证一下malloc( )和calloc() 的区别，free() 我们在后面详细介绍。

int main()
{
    int* p = (int*)malloc(40); // 开辟40个空间
    //int* p = (int*)calloc(10, sizeof(int)); // 开辟10个大小为int的空间，40

    if (p == NULL)
    {
        perror("malloc failed");   //p 现在指向有 10 个元素的数组
    }
    for (int i = 0; i < 10; i++)
        printf("%d ", *(p + i));
    
    free(p);
    p = NULL;

    return 0;
}

calloc() 会对内存进行初始化，把空间的每个字节初始化为 0 。如果我们对于申请的内存空间的内容要求初始化，我们就可以使用 calloc() 函数来轻松实现。

3. realloc() 函数

realloc() 函数用于重新调整之前调用 malloc() 或 calloc() 所分配的指针p 所指向的内存块的大小，可以对动态开辟的内存进行大小的调整。

#include<stdio>//realloc()头文件
//realloc
void* realloc(void*ptr size_t size)
//ptr 先前maolloc calloc realloc 申请空间的首地址
//size_t 无符号类型
//size:申请的新内存大小，单位字节
//void* 需利用强制类型转成所需要的指针类型
//返回值：返回调整后空间的起始地址，调整失败返回NULL指针

realloc() 空间扩容存在如下四种情况：

代码演示：

int main()
{
	int* p = (int*)malloc(10 * sizeof(int));
	if (p == NULL)
	{
		perror("malloc failed");    //p 现在指向有 10 个元素的数组
	}
	for (int i = 0; i < 10; i++) //对数组元素赋值
	{
		*(p + i) = i;
	}
	int* ptr = (int*)realloc(p, 20 * sizeof(int)); //对动态内存大小进行调整
	
	if (ptr == NULL) //调整失败并不影响原本p指向空间
	{
		perror("realloc failed");
	}
	else
	{
		p = ptr; //调整成功，p指向调整后空间起始地址
		for (int i = 10; i < 20; i++) //对数组元素赋值
		{
			*(p + i) = i;
		}
		for (int i = 0; i < 20; i++) //打印数组元素
		{
			printf("%d ", *(p + i));
		}
	}
	free(p); //释放p所指向动态内存分配的空间
	p = NULL;//将p置为NULL指针，防止访问一个已释放的空间
	return 0;
}

4.free() 函数

free() 函数是为了释放按需申请的空间,防止内存泄漏。需要注意的是如果 ptr 指向的空间不是动态开辟的，那么 free 函数的行为是未定义的。如果参数 ptr 是 NULL 指针，那么 free 将不会执行任何动作。

#include<stlib>//free()头文件
//free
void free(void*ptr e)
//ptr 先前maolloc calloc realloc 申请空间的首地址

因此我们在使用完申请的内存空间后一定要记得使用 free 函数释放所开辟的内存空间。使用指针指向动态开辟的内存，使用完并 free() 之后一定要记得将其置为空指针，防止越界访问。free()函数只会释放ptr指向空间的值，但 ptr 本身不会被置空。

二 . C++动态内存管理

C语言动态内存管理方式在C++中可以继续使用，同时C++又提出了自己的内存管理方式，通过new 和 delete操作符来进行动态内存管理。

1. new delete 操作符内置类型的动态内存管理

首先我们来看C++是如何对内置类型动态申请空间的：

int *p1 = new int; //申请一个int类型的空间

int *p2 = new int(10); // 动态申请一个int类型的空间并初始化为10

int* p3 = new int[10];// 动态申请10个int类型的空间

int* p4 = new int[10]{1,2,3,4,5};// 动态申请10个int类型的空间并初始化

既然申请了，我们就要去释放这些空间，C语言中使用free()，但是在C++中呢，我们使用 delete 对于普通的空间我们直接delete即可，但是对于数组来说，我们要使用delete[ ]。

delete p1;
delete p2;
delete[] p3;
delete[] p4;

对于内置类型而言，用malloc和new，除了用法不同，没有什么区别。 它们的区别在于自定义类型

2. new delete 操作符自定义类型的动态内存管理

我们在这里首先给出结论：在申请空间时 malloc 只开空间，new既开空间又调用构造函数初始化；在释放空间时，delete会调用析构函数，free不会。

首先来看，malloc 和 free

#include<iostream>
using namespace std;
class Test
{
public:
	//构造函数
	Test(int x = 1) :_a(x)  //初始化列表
	{
		cout << "Test.()" << this << endl;
	}
	// 析构函数
	~Test()
	{
		cout << "~Test.()" << this << endl;
	}
private:
	int _a;
};

void Test1()
{
	// 申请单个Test类型的空间
	Test* p1 = (Test*)malloc(sizeof(Test));
	// 申请10个Test类型的空间
	Test* p2 = (Test*)malloc(sizeof(Test) * 10);

	free(p1);
	free(p2);
}
int main() 
{
	Test1();
	return 0;
}

很明显，malloc的对象只是开辟了空间，并没有初始化，free后也只是普通的释放。

再看一下new 和 delete

class Test
{
public:
	//构造函数
	Test(int x = 1) :_a(x)  //初始化列表
	{
		cout << "Test.()" << this << endl;
	}
	// 析构函数
	~Test()
	{
		cout << "~Test.()" << this << endl;
	}
private:
	int _a;
};
void Test2()
{
	// 申请单个Test类型的空间
	Test* p3 = new Test(5);
	// 申请10个Test类型的空间
	Test* p4 = new Test[10]{ 1,2,3,5,4 };

	delete p3;
	delete[] p4;
}

int main() 
{
	Test2();
	return 0;
}

很明显，使用 new，既可以开辟空间，又调用了构造函数从而完成初始化，而delete时调用了析构函数，以此释放空间。同时需要注意的是，malloc, free ,new,delete 不能混用。

3.malloc/free和new/delete的区别

malloc/free和new/delete的共同点是：都是从堆上申请空间，并且需要用户手动释放。

不同的地方是：

malloc和free是函数，new和delete是操作符
malloc申请的空间不会初始化，new可以初始化
malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可，如果是多个对象，[]中指定对象个数即可
malloc的返回值为void*, 在使用时必须强转，new不需要，因为new后跟的是空间的类型
malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new不需要，但是new需要捕获异常
申请自定义类型对象时，malloc/free只会开辟空间，不会调用构造函数与析构函数，而new在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成空间中资源的清理。