1.C/C++内存分布
在介绍C/C++的内存分布情况之前，我们先看看以下几道题目，观察一下不同类型数据是存储在内存的哪些地方。
#include<iostream>
using namespace std;
int global_var = 1;//全局变量，存放在数据段
static int staticGlobalvar = 1; // 静态的全局变量存放再数据段
int main()
{
static int static_var = 1;//尽管是局部变量，但是是静态的，也放在数据段类
int local_val = 1;//局部变量，存放在栈
int num1[10] = { 1, 2, 3, 4 };//局部开辟的数据，也是局部变量存放在栈
char char2[] = "abcd";//char2是在局部开辟的数组，存放的是首元素地址，在局部开辟，所以是局部变量，存放在栈上。同理*char2指的就是首元素，尽管"abcd"是常量字符串，但是*char2指向是为"abcd"开辟的空间）——即数组char2，所以*char2还是在栈上
const char* pchar3 = "abcd";//局部创建的指针，在栈上，*pchar3指向的是常量"abcd"，故在代码段（常量区）
int* ptr1 = (int*)malloc(sizeof(int) * 4);//prt1局部创建的指针，在栈上，*ptr1指向的是为它动态开辟的空间，在堆上
int* ptr2 = (int*)calloc(4, sizeof(int));
int* ptr3 = (int*)realloc(ptr2, sizeof(int) * 4);
free(ptr1);
free(ptr3);
return 0;
}
通过以上几个例子，我们可以总结一下C/C++内存空间的分布： （1）内核空间，内核空间是提供给系统使用的，用户无法使用。 （2）栈，又叫堆栈，存储非静态的局部变量、函数参数、返回值等等，且栈是向下增长的。 （3）堆，程序运行时动态内存分配时使用的空间，可以向上增加。 （4）数据段，静态区，存储全局变量或静态数据。 （5）代码段，常量区，可执行代码和只读常量存放的地方。
2.C语言动态内存管理方式
C语言动态内存管理方式主要是malloc calloc realloc 与free，我们先来回顾一下：
int main()
{
//malloc，开辟指定的空间返回void*指针
int* p1 = (int*)malloc(sizeof(int) * 4);
//calloc，在malloc的基础上还能将开辟的空间初始化为0
int* p2 = (int*)calloc(4, sizeof(int) * 4);
//realloc，可以动态调整空间大小，
int* p3 = (int*)realloc(p2, sizeof(int) * 4);
//free，针对动态开辟的空间，进行内存释放，如果不是动态开辟的，则free不作为
free(p3);
return 0;
}
3.C++动态内存管理方式
C语言中的动态内存管理方式在C++里依旧可以使用，但是仍然有些不便，同时使用起来也相对麻烦一点，因此C++提出了自己的内存管理方式：通过new和delete进行动态内存管理。
3.1new/delete操作内置类型
int main()
{
//动态申请一个int类型的空间
int* ptr1 = new int;
cout << *ptr1 << endl;
//动态申请一个int类型的空间并且初始化为10
int* ptr2 = new int(10);
cout << *ptr2 << endl;
//动态申请3个int类型的空间
int* ptr3 = new int[3];
cout << sizeof(*ptr3) << endl;
cout << sizeof(int[3]) << endl;
//没想明白*ptr3和int[3]的区别去看看数组和指针哈
delete ptr1;
delete ptr2;
delete[] ptr3;
return 0;
}
通过以上几个例子，我们可以总结一下：
（1）申请和释放单个元素的内存空间，用的是new和delete，申请和释放连续的内存空间，用的是new[]和delete[]，注意匹配起来使用。
（2）开辟空间用指针接受，同时可以进行初始化。
3.2new/delete操作自定义类型
//自定义类型
class A
{
public:
//构造函数
A(int a = 0)
:_a(a)
{
cout << 1111 << endl;
}
//析构函数
~A()
{
cout << 2222 << endl;
}
private:
int _a;
};
int main()
{
//内置类型
int* q1 = (int*)malloc(sizeof(int));
int* q2 = new int(10);
//自定义类型
A* p1 = (A*)malloc(sizeof(A));
A* p2 = new A;
free(q1);
delete q2;
free(p1);
delete p2;
return 0;
}
对于内置类型，malloc、free和new、delete在在操作上没有区别，但是申请自定义类型空间时，new会调用自定义类型对应的构造函数，delete会调用对应的析构函数，但是malloc和free不会。
4.operator new与operator delete函数
new和delete是用户进行动态内存申请和释放的操作符，operator new与operator delete是系统提供的全局函数，new会在底层调用operator new全局函数申请空间，而delete会在底层调用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 );
__FINALLY
_munlock(_HEAP_LOCK); /* release other threads */
__END_TRY_FINALLY
return;
}
/*
free的实现
*/
#define free(p) _free_dbg(p, _NORMAL_BLOCK)
通过以上两个全局函数的实现我们可以发现，operator new 实际也是通过malloc来申请空间，如果malloc申请空间成功就直接返回，否则执行用户提供的空间不足应当措施，如果用户提供该措施就继续申请，否则就抛异常。operator delete 最终是通过free来释放空间的。
5.new和delete实现的底层原理
5.1内置类型
如果申请的是内置类型的空间，new和malloc，delete和free基本类似，不同的地方是：new/delete申请和释放的是单个元素的空间，new[]和delete[]申请的是连续空间，而且new在申请空间失败时会抛异常，malloc会返回NULL。
5.2自定义类型
(1)new的原理
调用operator new函数申请空间。同时在申请的空间上执行构造函数，完成对象的构造。
（2）deldete的原理
在空间上执行析构函数，完成对象中资源的清理工作。调用operator delete函数释放对象的空间。
（3）new T[N]的原理
调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对象空间的申请.在申请的空间上执行N次构造函数 （4）delete[]的原理
在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理调用operator delete[]释放空间，实际在operator delete[]中调用operator delete来释放空间。
class A
{
public:
//构造函数
A(int a = 0)
:_a(a)
{
cout << 1111 << endl;
}
//析构函数
~A()
{
cout << 2222 << endl;
}
private:
int _a;
};
int main()
{
//内置类型
int* q1 = (int*)malloc(sizeof(int));
int* q2 = new int(10);
//自定义类型
A* p1 = (A*)malloc(sizeof(A));
A* p2 = new A;
A* p3 = new A[3];
free(q1);
delete q2;
free(p1);
delete p2;
delete[] p3;
return 0;
}
6.malloc/free 和 new/delete 的区别
（1）malloc/free都是函数，而new/delete是操作符。
（2）malloc申请空间不会初始化，但是new可以初始化。要注意，new仅仅是调用拷贝构造函数初始化对象，而不是创建对象。
（3）malloc申请空间时需要计算大小且手动传递，new只需在其后跟上空间类型即可。
（4）malloc的返回值是void*，使用时 需要强转，但是new不需要，new后跟的是空间的类型。
（5）malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new不需要，但是new需要捕获异常。
（6）申请自定义类型对象时，malloc/free只会开辟空间，不会调用构造函数与析构函数，而new在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成空间中资源的清理。
当然，malloc/free和new/delete的也有共同点：都需要从堆上申请空间，并且需要用户手动释放。
7.内存泄漏
7.1什么是内存泄漏，内存泄漏的危害
在程序运行中，我们可能因为疏忽或者错位导致本来应该释放的内存未能及时释放，或者出现内存已经不能再使用的情况。内存泄漏并不是内存再物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对这段内存的控制，导致内存浪费。
内存泄露的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统，后台服务，服务器等等，出现内存泄漏会导致响应越来越慢，最终卡死。
7.2内存泄漏的分类
堆内存泄漏
在之前，我们要先看看内存泄漏对于栈、堆的危害程度。
对于栈而言，栈是自动管理内存的，因此不需要担心内存泄漏的问题，对于堆，堆需要用户自己申请和释放，所以对于堆而言，一定要注意释放申请的内存空间。
堆内存指的是程序执行中依据需要通过malloc/calloc/ralloc/new等从堆内申请内存，用完后必须通过调用相应的free或者delete释放。假设程序设计错误内存没有被释放，那么这部分空间将无法再被使用，就会产生堆内存泄漏。
系统资源泄漏
指程序使用系统分配的资源，比如套接字，文件秒速，管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重的可能导致系统效能减少，系统执行不稳定。
7.3如何避免内存泄漏
（1）在程序设计之初保持良好的代码的规范，申请的内存记得匹配释放，当然在一些异常情况下，也有可能出现问题。
（2）采用智能指针来管理资源。
（3）使用内存泄漏检测工具来检测。
