C/C++内存管理 - 技术栈

目录标题

1.C/C++内存管理
2.C语言中的动态内存管理方式：malloc/calloc/realloc/free
3.C++内存管理方式
- 3.1new/delete操作内置类型
- 3.2new和delete操作自定义类型
[4.operator new与operator delete函数](#4.operator new与operator delete函数)
- [4.1operator new与operator delete函数](#4.1operator new与operator delete函数)
5.new和delete的实现原理
- 5.1内置类型
- 5.2自定义类型
6.定位new表达式(placement-new)(了解)
7.总结
- 7.1malloc/free和new/delete的区别
- 7.2内存泄漏
- - 7.2.1什么是内存泄漏以及内存泄漏的危害
  - 7.2.2内存泄漏的分类
  - [7.2.3 如何避免内存泄漏](#7.2.3 如何避免内存泄漏)

1.C/C++内存管理

我们先从下面一段代码来引入内存管理

cpp 复制代码

int globalval = 1;
static int staticGlobalval = 1;//全局变量和全局静态变量都位于静态区上
void Test()
{
	static int staticvar = 1;//静态局部变量位于静态区
	
	int localval = 1;
	int nums1[10] = {1 , 2 , 3 , 4};//普通局部变量位于栈上
	
	char char2[] = "abcd";//这里是将常量区的abcd拷贝到栈上，*char，是对数组首地址的解引用，也是位于栈上
	
	const char* pChar3 = "abcd";//pChar3是一个指针，指向位于常量区的abcd，所以位于栈上
								//*pChar是对常量区字符串首地址的解引用，所以位于常量区		
	int* ptr1 = (int*)malloc(sizeof(int)*4);
	int* ptr2 = (int*)calloc(4,sizeof(int));		
	int* ptr1 = (int*)realloc(ptr2,sizeof(int)*4);//动态开辟的内存空间是位于堆上
	free(ptr1);
	free(ptr3);
}

从下面题目，我们来了解上述代码中的变量在内存中的分布情况

1.选择题：

globalVar在哪里？C staticGlobalVar在哪里？C

staticVar在哪里？ C localVar在哪里？A

num1在哪里？ A

char2在哪里？ A *char2在哪里？A

pChar3在哪里？ D *pChar3在哪里？D

ptr1在哪里？ A *ptr1在哪里？B

选项：A，栈 B，堆 C，数据段(静态区) D，代码段(常量区)

2.填空题

sizeof(num1) = 40

sizeof(char2) = 5 strlen(char2) = 4

sizeof(pChar3) = 4/8 strlen(pChar3) = 4

sizeof(ptr1) = 4/8

3.sizeof和strlen的区别？

sizeof是一个计算数据类型所占空间大小的单目运算符，在计算字符串空间大小时，包含了结束符\0的位置；

而strlen是一个计算字符串长度的函数，在使用时需要引入头文件#include<string.h>，不包含\0，即计算\0之前的字符串的长度

说明：

1.堆又叫做堆栈，非静态局部变量，函数参数，返回值等等都是位于栈上，注意栈空间是向下增长的

2.内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库，用户可使用系统接口创建共享内存，叫做进程间通信

3.堆用于程序运行时动态内存分配，堆是可以上增长的

4.数据段--用于存储全局数据和静态数据

5.代码段--可执行代码、只读常量

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

c 复制代码

void Test()
{
	int* p1 = (int*)malloc(sizeof(int));
	free(p1);
	
	int* p2 = (int*)calloc(4,sizeof(int));
	int* p3 = (int*)realloc(p2,sizeof(int) * 10);
	
	//这里需要free(p2)吗？不需要
	free(p3);
}

1.malloc/calloc/realloc的区别？

(1).malloc函数，其原型是void *malloc(unsigned int num_bytes);

nums_byte为要申请空间的大小，需要我们去手动计算，如：int* p = (int*)malloc(20*sizeof(int)),如果编译器默认

int为4个字节存储的话，那么该函数就会一次性申请一个80byte的连续空间，并将空间基地址强制转换为int类型，

并赋值给指针p，此时申请的内存值是随机值

(2).calloc函数，其原型是void* calloc(size_t n,size_t size);

calloc比malloc函数多一个参数，并不需要人为计算空间的大小，比如要申请20个int类型空间，int* p = (int*)calloc(20,sizeof(int)),它与malloc的区别就在于，malloc申请后的空间的值是随机的，并没有对空间中的值进行初始化，而calloc却在申请后，对空间逐一进行初始化，并设置值为0，因此calloc的效率必然是要比malloc要低的

(3).realloc函数与上述两个有本质的区别，其原型是void realloc(void* ptr,size_t new_size)

c 复制代码

int main()
{
	const int size = 2000;
	int* p = (int*)malloc(20*sizeof(int));
	int* pp = (int*)realloc(p,size*sizeof(int));
	printf("原来的p_Address:%x	扩容后的pp_Address:%x\n",p,pp);
}

扩容后的地址发生了改变，说明发生了异地扩容，详细说明如下：

realloc用于动态内存进行扩容(即已经申请的动态空间不够使用，需要进行空间扩容)，ptr为指向原来空间基地址的指针，new_size为接下来需要扩容容量的大小

实际上：

如果size较小，原来申请的动态内存后面还有空余内存，系统将直接在原内存空间后面扩容，并返回原动态空间基地址；如果size较大，原来申请的空间后面没有足够大的空间扩容，系统将重新申请一块(20+size)*sizeof(int)的内存，并把原来空间的内容拷贝过去，原来的空间free；但是如果size非常大的话，系统内存申请失败，返回NULL原来的内存不会释放。注意：如果扩容后的内存空间较原空间小，将会出现数据丢失，如果直接realloc(p,0)；相当于free§;

3.C++内存管理方式

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

3.1new/delete操作内置类型

cpp 复制代码

void Test()
{
	int* ptr1 = new int;
	//动态申请一个int类型的空间
	
	int* ptr2 = new int(10);
	//动态申请一个int类型的空间并初始化为10
	
	int* ptr3 = new int[3];
	//动态申请3个int类型的空间,[]内的是申请变量的个数
	
	int* ptr4 = new int[10] {1,2,3,4,5};
	//动态申请10个int类型的空间，并将前5个元素进行初始化
	
	//释放动态开辟的内存空间
	delete ptr1;
	delete ptr2;
	delete[] ptr3;
}

注意：申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用new[]和delete[]，注意：匹配起来使用

3.2new和delete操作自定义类型

cpp 复制代码

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

int main()
{
	A* p1 = (A*)malloc(sizeof(A));
	A* p2 = new A(1);
	free(p1);
	delete p2;
	//	new/delete和malloc/free最大区别是new/delete对于自定义类型除了开空间，还会调用构造函数和析构函数
	
	int* p3 = (int*)malloc(sizeof(int));
	int* p4 = new int;
	free(p3);
	delete p4;
	//内置类型几乎是一样的

	/*A* p5 = (A*)malloc(sizeof(A) * 10); 
	A* p6 = new A[10];
	free(p5);
	delete[] p6;
	return 0;*/
}

运行结果说明：new和delete调用了构造函数和析构函数

注意：在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，而malloc和free却不会

4.operator new与operator delete函数

4.1operator new与operator delete函数

new和delete是用户进行动态内存申请和释放的操作符

operator new和operator delete都是系统提供的全局函数

new在底层调用operator new全局函数来申请空间

delete在底层通过operator delete全局函数来释放空间

其实operator new是对malloc的封装

operator delete是对free的封装

这里以new为例介绍一下其在底层会进行那些操作：

new是操作符，在编译时会转换为相应的指令，去调用operator new，进而调用malloc和构造函数

即new -> operator new -> malloc+构造函数(如果是内置类型则不需要调用构造函数，否则就需要调用构造函数)

同样：new[n]->operator new[n] ->operator new ->malloc + n次构造函数

5.new和delete的实现原理

5.1内置类型

如果申请的是内置类型的空间，new和malloc，delete与free基本类似，不同的地方是：new/delete申请和释放的是单个元素的空间，new[]和delete[]申请和释放的是连续空间，而且new在申请空间失败时会抛异常，malloc会返回NULL。

5.2自定义类型

new的原理：

1.调用operator new函数申请空间

2.在申请的空间上执行构造函数，完成对象的构造
delete的原理：

1.在空间上执行析构函数，完成对象中的资源清理工作

2.调用operator 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来释放空间

6.定位new表达式(placement-new)(了解)

定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象

使用格式：new(place_address)type或者new(place_address)type(initializer-list)

place_address必须是一个指针，initializer-list是类型的初始化列表

使用场景：

定位new表达式在实际中一般是配合内存池使用，因为从内存池中分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new定义表达式进行显示调用构造函数进行初始化

cpp 复制代码

class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A():" << this << endl;
	}
	~A()
	{
		cout <, "~A():" << this << endl;
	}
private:
 	int _a;
}
int main()
{
	A* p1 = (A*)malloc(sizeof(A));
	//p1现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
	new(p1)A;//注意：如果A类的构造函数中的参数无缺省值的话，需要传参
	p1->~A();
	free(p1);


	A* p2 = (A*)operator new(sizeof(A));
	new(p2)A(10);
	p2->~A();
	operator delete(p2);
	return 0;
}

7.总结

7.1malloc/free和new/delete的区别

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

1.malloc和free是函数，而new和delete是操作符(关键字类型)

2.malloc申请的空间不会初始化，new可以初始化(对申请的空间是否初始化)

3.malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间类型即可，如果是多个对象，[]中指定

对象个数即可(是否需要手动计算空间大小)

4.malloc的返回值为void*，在使用的时候必须强转，new不需要，因为new后跟的是空间的类型(返回值)

5.malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new不需要，但是new需要捕获异常(申请空间失败后)

6.申请自定义类型对象时，malloc/free只会开辟空间和释放空间，不会调用构造函数和析构函数，而new在申请空间后会调用构造函数完成对象的初始化，delete在释放空间之前会调用析构函数完成空间中资源的清理工作(构造和析构方面)

7.2内存泄漏

7.2.1什么是内存泄漏以及内存泄漏的危害

内存泄漏：简单可以理解为：对于一块我们已经不再使用的空间，我们并没有对其进行释放

详细解释：如果我们去new一个对象，这时候就需要向系统申请内存进行使用，然后系统在堆内存给这个对象申请一块内存空间，当我们使用完，却没有及时释放，导致这个不使用的对象一直占据内存单元，造成系统不能再把它分配给需要的程序
内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，比如操作系统，后台服务等等，出现内存泄漏，会导致响应越来越慢最终卡死。

7.2.2内存泄漏的分类

C/C++程序中一般我们关心方面的内存泄漏：

1.堆内存泄漏(Heap leak）

堆内存指的是程序执行中通过malloc/calloc/realloc/new等从堆中分配的一块内存，用完必须通过调用相应的free或者delete去释放内存，假设程序设计错误导致这部分没有被释放，那么以后这部分空间将无法被使用，就会产生Heap Leak

2.系统资源泄漏

指程序使用系统分配的资源，比方说：套接字，文件描述符，管道等，使用完后没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定

7.2.3 如何避免内存泄漏

工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。

采用RAII思想或者智能指针来管理资源。
3.出问题了使用内存泄漏工具检测。

总结一下:

内存泄漏非常常见，解决方案分为两种：1、事前预防型。如智能指针等。2、事后查错型。如泄

漏检测工具。