C/C++内存管理

1.C/C++内存管理

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

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

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)

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操作内置类型

void Test()
{int* ptr1 = new int;//动态申请一个int类型的空间int* ptr2 = new int(10);//动态申请一个int类型的空间并初始化为10int* 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操作自定义类型

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定义表达式进行显示调用构造函数进行初始化

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 如何避免内存泄漏

1. 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。
2. 采用RAII思想或者智能指针来管理资源。
   3.出问题了使用内存泄漏工具检测。

总结一下:
内存泄漏非常常见，解决方案分为两种：1、事前预防型。如智能指针等。2、事后查错型。如泄
漏检测工具。