【c/c++】内存管理

1.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";
 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.代码段

globalVal在哪里？  数据段
staticGlobalVar在哪里？数据段
staticVar在哪里？数据段
localVar在哪里?  栈
num1在哪里？栈


char2在哪里?栈
*char2在哪里？栈
pchar3在哪里？栈
*pchar3在哪里？代码段
ptr1在哪里？栈
*ptr1在哪里？堆

2.填空题：

sizeof(num1) =40
sizeof(char2)=5
strlen(char2)=4
sizeof(pChar3)=4/8
strlen(pChar3)=4
sizeof(ptr1)=4/8
sizeof(ptr2)=4/8

指针的4/8与进程地址空间有关系。
指针的本质是内存字节的编号。
32位malloc最大不超过3G大概就2G。
要超过3G，就换成64位。
一般栈就十几个M。
高一G内核
低三G？？（栈堆之类）
32位（2的32次方）与64位（2的64次方）跟进程有关系。
进程由编译器控制，编译器由人控制。

说明：

1. 栈又叫堆栈，非静态局部变量/函数参数/返回值等等，栈是向下增长的。
2. 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共
享内存，做进程间通信。（现 在只需要了解一下）
3. 堆用于程序运行时动态内存分配，堆是可以上增长的。
4. 数据段--存储全局数据和静态数据。(c语言叫做静态数据区）
5. 代码段--可执行的代码/只读常量。（正文或常量区
不是自己的代码，是编译后二进制指令。）

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

详细请看：https://blog.csdn.net/weixin_41892460/article/details/82666228

void Test ()
{
 int* p1 = (int*) malloc(sizeof(int));
 free(p1);

 // 1.malloc/calloc/realloc的区别是什么？
 int* p2 = (int*)calloc(4, sizeof (int));
 int* p3 = (int*)realloc(p2, sizeof(int)*10);

 // 这里需要free(p2)吗？
 //不需要
 free(p3 );
}

3.C++内存管理方式

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

3.1new/delete操作内置类型

void Test()
{
 // 动态申请一个int类型的空间
 int* ptr4 = new int;

 // 动态申请一个int类型的空间并初始化为10
 int* ptr5 = new int(10);

 // 动态申请3个int类型的空间
 int* ptr6 = new int[3];

 delete ptr4;
 delete ptr5;
 delete[] ptr6;
}

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

3.2new和delete操作自定义类型

class Test
{
public:
 Test()
 : _data(0)
 {
 cout<<"Test():"<<this<<endl;
 }
 ~Test()
 {
 cout<<"~Test():"<<this<<endl;
 }

private:
 int _data;
};
void Test2()
{
 // 申请单个Test类型的空间
 Test* p1 = (Test*)malloc(sizeof(Test));
 free(p1);

 // 申请10个Test类型的空间
 Test* p2 = (Test*)malloc(sizoef(Test) * 10);
 free(p2);
}
void Test2()
{
 // 申请单个Test类型的对象
 Test* p1 = new Test;
 delete p1;

 // 申请10个Test类型的对象
 Test* p2 = new Test[10];
 delete[] p2;
}

new：
内置内型 ： malloc和new效果一样。
自定义类型： malloc与new不一样。
c++建议用new。
new对于自定义类型，不仅开空间并且调构造函数初始化。
而malloc只负责开空间。
注意匹配：malloc匹配free;new匹配delect。

delete:
对于内置类型，delect与free差不多；对于自定义类型，delect先析构，再释放空间。
注意匹配：new匹配delect；malloc匹配free。

扫描二维码关注公众号，回复： 3929669 查看本文章

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

4.operator new与operator delete函数

new和delete是用户进行动态内存申请和释放的操作符，operator new和operator delete是系统提供的全局变量，new在底层调用operator new全局函数来申请空间，如果malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常。delete在底层通过operator delete 全局函数来释放空间，而operator delete最终也是通过free来释放空间的。

注意：operator new和operator delete用户也可以自己实现，用户实现时即可实现成全局函数，也可实现成 类的成员函数，但是一般情况下不需要实现，除非有特殊需求。比如需要跟踪内存的申请与释放时。

5.new和delect的实现原理

5.1内置类型

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

5.2自定义类型

• new的原理
  1.调用operator new函数申请空间

内置类型

new int  ==》 operator new开空间 ==》 malloc  ==》 构造（失败抛异常）抛异常是为了复合c++的规范。失败就抛异常。

malloc int ==》 malloc （失败返回NULL）


int在c++有构造，为了兼容c++。

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

• delect的原理
  1.在空间上执行析构函数，完成对象中资源的清理工作
  2.调用operator delect函数释放对象的空间
• new T[N]的原理
  1.调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对象空间的申请
  2.在申请的空间上执行N次构造函数
• delect[]的原理
  1.在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理
  2.调用operator delete[]释放空间，实际在operator delect[]中调用operator delect来释放空间。

内置类型

new int  ==》 operator new开空间 ==》 malloc  ==》 构造（失败抛异常）抛异常是为了复合c++的规范。失败就抛异常。

malloc int ==》 malloc （失败返回NULL）


int在c++有构造，为了兼容c++。

6.定位new表达式（placement-new）

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

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

使用场景：
定位new表达式在实际中一般是配合内存池（池化技术：减少内存碎片可以提高效率。）使用。因为内存池分配出的内存没有初始化，所以如果是自定义 类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化。

class Test
{
public:
 Test()
 : _data(0)
 {
 cout<<"Test():"<<this<<endl;
 }
 ~Test()



 {
 cout<<"~Test():"<<this<<endl;
 }

private:
 int _data;
};
void Test()
{
 // pt现在指向的只不过是与Test对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
 Test* pt = (Test*)malloc(sizeof(Test));

 new(pt) Test; // 注意：如果Test类的构造函数有参数时，此处需要传参
}


// Test* pt = (Test*)malloc(sizeof(Test));

 new(pt) Test; 
等价于：Test* pt = new Test

7.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可以，new在申请空间后会调用构造函数完成对象的构造，delete在释放空间前会调用析构函数
完成空间中资源的清理
7. malloc申请的空间一定在堆上，new不一定，因为operator new函数可以重新实现
因为operator new可以重载导致可能在栈上开辟
8. new/delete比malloc和free的效率稍微低点，因为new/delete的底层封装了malloc/free