前言

一、 C/C++内存分布

在C语言的阶段，我们已经学习了C语言的内存分布，我们常说，局部变量存储在栈区，动态内存中的数据存储在堆区，静态变量和全局变量存储在静态区，常量存储在常量区，其实这些区域都是虚拟进程空间的一部分，其中具体内存区域的划分如下：

内核空间：操作系统内核-kernel,受硬件保护，用户不能进行读写，用于执行各种机器指令

栈：又叫堆栈–非静态局部变量/函数参数/返回值等等，栈是向下增长的

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

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

数据段(静态区)：–存储全局数据和静态数据

代码段(常量区)：–存储可执行的代码/只读常量

我们学习了C/C++内存区域的划分之后，那我们来看看下面的题目：

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);
}
1. 选择题：
   选项: A.栈  B.堆  C.数据段(静态区)  D.代码段(常量区)
   globalVar在哪里？____   staticGlobalVar在哪里？____
   staticVar在哪里？____   localVar在哪里？____
   num1 在哪里？____
   
   char2在哪里？____   *char2在哪里？___
   pChar3在哪里？____      *pChar3在哪里？____
   ptr1在哪里？____        *ptr1在哪里？____
2. 填空题：
   sizeof(num1) = ____;  
   sizeof(char2) = ____;      strlen(char2) = ____;
   sizeof(pChar3) = ____;     strlen(pChar3) = ____;
   sizeof(ptr1) = ____;
3. sizeof 和 strlen 区别？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

答案：1.选择题 C C C A A A A A D A B

​ 2.填空题： 40 5 4 4/8 4 4/8

​ 3.sizeof是操作符/关键字，后面不需要加括号，直接跟数据类型；而strlen是函数，调用时必须加上括号；sizeof是计算变量所占用的空间，而strlen是计算字符串中字符的个数，不包括’\0’

【注意】

1.sizeof(数组名)是计算整个数组的大小，strlen是计算字符非个数(不包括’\0‘)

2.*char2和*pChar3的存储区域–我们只带常量字符串“abcd”是存储在代码段(常量区)中的，不可以被修改，对于pChar3来说，它是一个指针，指向代码段的"abcd"，所以pChar是保存的’a‘的地址，所以pChar是栈中，而*pChar存储在代码段中，而char2是一个数组，数组是在栈上开辟空间，所以char2数组中的数据是从代码段拷贝过来的，所以char2和*char2都在栈区；

3.ptr1是一个指针，指向的是开辟空间的首地址，所以ptr1在栈区，而*ptr1在堆区

二、C语言中动态内存管理方式

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

void Test ()
{
    int* p1 = (int*) malloc(sizeof(int));
    if(p1 == NULL)
    {
        perror("malloc fail");
        return;
    }
    free(p1);
    // 1.malloc/calloc/realloc的区别是什么？
    int* p2 = (int*)calloc(4, sizeof (int));
    if(p2 == NULL)
    {
        perror("calloc fail");
        return;
    }
    int* p3 = (int*)realloc(p2, sizeof(int)*10);
    if(p3 == NULL)
    {
        perror("realloc fail");
        return;
    }
    // 这里需要free(p2)吗？
    free(p3 );
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

对于上面的代码，我们需要free(p2)吗

答案是不需要的，p3对p2所指向的空间进行扩容，扩容有两种方式，一种是原地扩，此时p2和p3指向同一块空间，free(p3)即可，二是异地扩，realloc在其他地方空间开辟空间的时候会释放原来的空间，所以也不需要我们对p2进行释放

malloc/calloc/realloc的区别是什么？

1.malloc是用于动态开辟一块内存空间，使用时需要指定开辟开辟空间的大小(单位是字节)，如果开辟成功就返回空间的起始地址，开辟释放则返回NULL，此外开辟的空间不会被初始化

2.calloc有两个参数，第一个参数是元素的个数，第二个参数是每个元素的大小，并且它会把空间的数据初始化为0(开辟成功)，开辟失败返回NULL

3.realloc用于空间的扩容和缩容，有两个参数，第一个参数是需要调整的空间的起始地址，第二个参数是调整后空间的大小，如果第一个参数为NULL，则此时realloc等价于malloc，如果扩容，编译器会检查原空间后面是否有足够的空间，如果足够，就直接扩容返回原空间的起始地址，如果不够，就重新找一块空间，然后将原空间的数据拷贝到新空间并返回新空间的起始地址，如果缩容，编译器会直接开辟一块空间，然后拷贝原空间数据到新的空间中并返回新空间的地址，再释放原来的空间，上面所以情况失败就返回NULL

拓展阅读：malloc的实现原理-glibc中malloc的实现原理

三、 C++内存管理方式

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

1.new/delete操作内置类型

对于内置类型，C语言和C++内存管理方式没有明显的区别，只有用法上的区别，C++使用new操作符(关键字)代替了C语言中的malloc和calloc函数，使用delete操作符(关键字)代替了free函数

由于new和delete都是操作符(关键字),而不是函数，所以他们后面不需要跟括号，而是直接跟类型即可，此外,new可以在开辟空间的同时进行初始化，但是C++不支持扩容，要扩容的话只能是自己重新开辟一块新的空间，然后拷贝数据，最后销毁原来的空间，和C语言的realloc函数实现一样

int main()
{
// 申请一个空间但不初始化
int* p1 = new int;

// 申请一个空间并进行初始化
int* p2 = new int(0);

// 申请多个空间不初始化
int* p3 = new int[10];

// 申请多个空间并进行初始化
int* p4 = new int[10]{ 1,2,3,4 };

// 释放单个空间
delete p1; 
delete p2;

// 释放多个空间
delete[] p3;
delete[] p4;

return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

【注意】

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

2.new和delete操作自定义类型

C++动态内存管理和C语言动态内存管理最大的区别在于二者对于自定义类型的处理，C语言中malloc/calloc/realloc函数只负责开辟空间，free函数只负责释放空间，而C++在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数

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

~A()
{
cout << "~A()" << endl;
}
};

int main()
{
A* p1 = new A;
delete p1;

A* p2 = new A[10];
delete[] p2;
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

C和C++开辟空间失败的区别

我们知道，不断开辟空间不进行是否或者开辟一块很大的空间就可能造成空间开辟失败，C语言是开辟空间失败失败返回的是一个空指针，所以我们可以通过检查指针是否为空来判断是否开辟成功，而C++是面向对象的语言，通常采用的是抛异常的方式，符合面向对象处理错误的方式

C语言方式

int main()
{
while (1)
{
// malloc失败 返回空指针
int* p1 = (int*)malloc(1024*100);
if (p1)
{
cout << p1 << endl;
}
else
{
cout << "申请失败" << endl;
break;
}
}
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

C++方式

void Test()
{
while (1)
{
// new失败 抛异常 -- 不需要检查返回值
char* p1 = new char[1024 * 1024 * 1024];
//char* p1 = (char*)operator new(1024 * 1024 * 1024);
cout << (void*)p1 << endl;
}
}

int main()
{
try
{
Test();
}
catch (exception& e)
{
cout << e.what() << endl;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

四、operator new与operator delete函数

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

【注意】

operator new和operator delete 函数不是new 和delete的运算符重载，因为他们的参数没有自定义类型，而是库里实现的全局函数，只是取名为operator new和operator delete,不要被运算符重载所误导，这个需要我们进行单独的记忆；

C++底层operator new和operator delete的函数实现：

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

// operator delete:
// 该函数最终是通过free来释放空间的
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);  //此处调用free函数
__FINALLY
_munlock(_HEAP_LOCK);  // release other threads
__END_TRY_FINALLY
return;
}

// free的实现
#define  free(p)        _free_dbg(p, _NORMAL_BLOCK)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

通过上述两个全局函数的实现知道，operator new实际也是通过malloc来申请空间，如果malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常,operator delete 最终是通过free来释放空间的

我们还可以通过查看反汇编来验证new和delete的底层调用

int main()
{
int* p1 = new int;
    delete p1;
}
1
2
3
4
5

对于new[]和delete[]来说，他们调用operator new[]和operator delete[]函数来实现其功能，但是他们的底层也是调用operator new 和operator delete 函数：

int main()
{
int* p2 = new int[10];
    delete[10] p2;
}
1
2
3
4
5

五、new和delete的实现原理

1.内置类型

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

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来释放空间

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

~A()
{
cout << "~A()" << endl;
}
};
int main()
{
A* p1 = new A;
delete p1;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

int main()
{
A* p2 = new A[10];
delete[] p2;
return 0;
}
1
2
3
4
5
6

我们可以看到，对于自定义类型，C++的new 和delete不仅会完成对空间的申请和释放，还会调用构造函数和析构函数完成初始化和清理资源的工作，这个就是C++在C语言已经有了malloc/calloc/realloc和free之后，还引入new和delete的原因

六、定位new表达式(placement-new)（了解）

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

使用格式：

new (place_address) type或者new (place_address) type(initializer-list)

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

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

~A()
{
cout << "~A()" << endl;
}
};

int main()
{
// 开辟一块和A一样大的空间
    // p1现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
A* p = (A*)malloc(sizeof(A));
if (p == nullptr)
{
perror("malloc fail");
exit(-1);
}
// 定位new -- 对p指向空间，显示调用构造函数初始化
new(p)A(1);
// 调用析构函数进行资源清理
p->~A();
free(p);
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

使用场景

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

内存池

内存池（Memory Pool）是一种动态内存分配与管理技术，通常情况下，程序员习惯直接使用new，delete，malloc,free等API申请和释放内存，这样导致的后果就是：当程序运行的时间很长的时候，由于所申请的内存块的大小不定，频繁使用时会造成大量的内存碎片从而降低程序和操作系统的性能。

内存池则是在真正使用内存之前，先申请分配一大块内存（内存池）留作备用。当程序员申请内存时，从池中取出一块动态分配，当程序员释放时，将释放的内存放回到池内，再次申请，就可以从池里取出来使用，并尽量与周边的空闲内存块合并。若内存池不够时，则自动扩大内存池，从操作系统中申请更大的内存池。

我们举一个简单的例子，假如一座山上有一个村庄，山脚下有一条河，这条河供全村人使用，每次使用的时候就需要到河边去取水，人多的时候就可能需要排队，这样就导致很慢，所以村长就想了一个办法–在家里修了一个蓄水池，通过抽水机将水输送到蓄水池中，需要用水的时候就特别方便，上述中全村人使用的河流就相当于栈，其他村民到河里打水就相当于malloc/calloc/realloc函数向栈申请空间，而村庄家的蓄水池就相当于内存池，内存池的建立就使得 我们在申请空间的时候效率就很高。

七、常见面试题

1.malloc/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在释放空间前会调用析构函数完成空间中资源的清理

2.内存泄漏

2.1什么是内存泄漏，内存泄漏的危害

什么是内存泄漏

内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内

存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对

该段内存的控制，因而造成了内存的浪费

内存泄漏的危害

长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现

内存泄漏会导致响应越来越慢，最终卡死

2.2内存泄漏分类（了解）

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

1.堆内存泄漏(Heap leak)

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

2.系统资源泄漏

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

2.3如何检测内存泄漏（了解）

在vs下，可以使用windows操作系统提供的**_CrtDumpMemoryLeaks()** 函数进行简单检测，该函数只报出了大概泄漏了多少个字节，没有其他更准确的位置信息。

int main()
{
 int* p = new int[10];
 // 将该函数放在main函数之后，每次程序退出的时候就会检测是否存在内存泄漏
 _CrtDumpMemoryLeaks();
 return 0;
}

// 程序退出后，在输出窗口中可以检测到泄漏了多少字节，但是没有具体的位置
Detected memory leaks!
Dumping objects ->
{79} normal block at 0x00EC5FB8, 40 bytes long.
Data: <                > CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD
Object dump complete.
1
2
3
4
5
6
7
8
9
10
11
12
13
14

因此写代码时一定要小心，尤其是动态内存操作时，一定要记着释放。但有些情况下总是防不胜防，简单的可以采用上述方式快速定位下。如果工程比较大，内存泄漏位置比较多，不太好查时一般都是借助第三方内存泄漏检测工具处理的

在linux下内存泄漏检测：Linux下几款内存泄漏检测工具

在windows下使用第三方工具：VHD工具说明

其他工具：内存泄漏工具比较

2.4如何避免内存泄漏

1.工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。ps：这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智能指针来管理才有保证

2.采用RAII思想或者智能指针来管理资源

3.有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项

4.出问题了使用内存泄漏工具检测。ps：不过很多工具都不够靠谱，或者收费昂贵

【总结】

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