C/C++的内存分布
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";
//字符数组存在栈区，“abcd”常量字符串在常量区
const char* pChar3 = "abcd";
//pChar3局部变量在栈区，“abcd”常量字符串在常量区
int* ptr1 = (int*)malloc(sizeof(int) * 4);
int* ptr2 = (int*)calloc(4, sizeof(int));
int* ptr3 = (int*)realloc(ptr2, sizeof(int) * 4);
//ptr1，ptr2，ptr3都是局部变量在栈区，其指向的空间在堆区
free(ptr1);
free(ptr3);
}
C中动态内存管理
-
malloc
参数是想要开辟内存空间的大小（字节），返回值是void* 根据需要进行强制类型转换。
所开辟的空间不进行初始化。 -
calloc
两个参数，作用是开辟几个每个所需要的空间是多少（字节）
所开辟的空间被初始化为0。
例如：
int* a = (int*)calloc(10,sizeof(int));
realloc
对ptr所指向的空间进行调整，可以扩容可以缩容，但一般用来扩容使用，若第一个参数是空指针，那么它的作用等同于malloc
扩容
- 原地扩容：若当前空间后面仍有大量空间可供扩容使用，那么就会原地扩容。
-
异地扩容：若当前空间后面没有足够空间供扩容使用，那么系统会重新找一块足够大的空间，将原空间的数据拷贝到新空间，并且将原空间释放。
free
释放在堆区动态开辟的空间
思考题：
4. malloc/calloc/realloc的区别？
malloc和calloc是从堆区上申请空间，realloc是对原空间的大小进行调整。
realloc第一个参数为NULL时，相当于malloc。
malloc申请空间不初始化，calloc申请空间并初始化。
realloc在扩容时存在原地扩容和异地扩容的问题。
C++中动态内存管理
C中的动态内存管理函数，已经不能完全满足C++的需要，所以C++中出现了新的动态内存管理的方式：new 和 delete操作符进行动态内存管理。
new delete操作内置类型
- new
int* p1 = new int;
int* p2 = new int[10];
可以看到用new操作符进行动态资源的申请是很方便的，不用强制类型转换，也不需要计算要开辟空间的大小，还有一点就是不需要在申请后检查是否开辟成功。
malloc申请空间失败后返回空指针，所以在使用malloc申请资源后要进行检查，而new 操作符开辟失败后是采用抛异常的方式，不需要检查。
另外，new在申请空间的同时，可以对其进行初始化：
int *p1 = new int(6);
int* p2 = new int[6]{1,2,3,4,5,6};
- delete
delete释放new出来的空间，且要配套使用，delete对应new delete[ ]对应new [ ]，如果不配套使用可能会出现问题（后面会提到）。
int* p1 = new int[6];
delete p1;
这样就会出错的。
new delete操作自定义类型
class A
{
public:
A(int a = 0,int b = 0)
:_a(a)
,_b(b)
{
cout << "A()" << endl;
}
~A()
{
cout << "~A()" << endl;
}
private:
int _a;
int _b;
};
int main()
{
A* p = (A*)malloc(sizeof(A));
if (p == NULL)
{
perror("malloc fail\n");
exit(-1);
}
free(p);
A* ptr = new A;
delete ptr;
return 0;
}
可以看到malloc和free并不会调用自定义类型的构造和析构函数。
new 和 delete 调用了自定义类型的构造和析构函数。
所以new 和 delete 是为了自定义类型而生的，对于内置类型与malloc和free没有什么区别（只是使用上的区别），但是对于自定义类型来说，new会调用构造函数，delete会调用析构函数。
构造函数不能显示调用（可以用定位new调用）
析构函数可以显示调用
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 new 是全局函数，是对malloc的封装，申请失败就不会在返回空指针，而是抛异常。
/*
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;
}
operator delete也是全局函数，是对free的封装。
new 和 delete实现原理
- new
1，调用operator new申请空间
2，调用构造函数 - new [ ]
1，调用opeartor new[ ]函数，就是调用多次operator new函数，申请多个空间
2，调用多次构造函数 - delete
1，在申请的空间上调用析构函数，完成对对象的清理。
2，调用operator delete函数释放申请的空间 - delete[ ]
1，在申请的空间上调用多次析构函数，完成对对象的清理。
2，调用operator delete [ ]，就是调用operator delete 函数来释放空间。
为什么说new delete new[] delete[] malloc free 要配套使用，下面的例子足以证明：
讲一下，new[ ],和delete[ ]是如何实现的？
int* p1 = new int[6];
[6]就会告诉编译器，要申请6个int大小的空间，并完成6次构造函数的调用。
delete[] p1;
delete[ ]并没有写明释放几个对象的空间，调用几次析构函数，他是如何完成的呢？
实际上new [ ]的时候编译器会做一些小操作，让其多开辟4个字节的空间，存放开辟几个对象的空间以让delete [ ]使用。
如果此时你用delete或者是free来释放此段空间会报错，因为不允许从中间部分来释放动态开辟的空间。并为只会调用一次析构，不能对所有对象完成清理工作。
class A
{
public:
A(int a = 0,int b = 0)
:_a(a)
,_b(b)
{
cout << "A()" << endl;
}
~A()
{
cout << "~A()" << endl;
}
private:
int _a;
int _b;
};
int main()
{
A* ptr1 = new A[6];
delete ptr1;
return 0;
}
定位new的使用
上面提到malloc操作自定义类型时，不会调用构造函数，采用定位new 的方式能够显示调用构造函数。文章来源：https://www.toymoban.com/news/detail-407936.html
class A
{
public:
A(int a = 0,int b = 0)
:_a(a)
,_b(b)
{
cout << "A()" << endl;
}
~A()
{
cout << "~A()" << endl;
}
private:
int _a;
int _b;
};
int main()
{
A* ptr = (A*)operator new(sizeof(A));
new(ptr)A(2, 3);
return 0;
}
定位new后
这里只是为了举例，定位new通常是配合内存池使用的。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化。文章来源地址https://www.toymoban.com/news/detail-407936.html
到了这里，关于C/C++内存管管理的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
