C++内存管理

Posted 2021-11-11 aaaaaaaWoLan

C/C++中程序内存区域划分：

注：const变量不在代码段(常量区)，属于自己的栈帧，或者如果是全局或静态的，就在数据段中(静态区)

【说明】

1. 栈又叫堆栈，非静态局部变量/函数参数/返回值等等，栈是向下增长的。
2. 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共
   享内存，做进程间通信。
3. 堆用于程序运行时动态内存分配，堆是可以向上增长的。但是也不一定，因为有可能下一次申请的是之前释放的
4. 数据段–存储全局数据和静态数据。
5. 代码段–可执行的代码/只读常量。

我们先来看下面的一段代码和相关问题

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.代码段
globalVar在哪里？____ staticGlobalVar在哪里？____
staticVar在哪里？____ localVar在哪里？____
num1 在哪里？____
char2在哪里？____ *char2在哪里？___
pChar3在哪里？____ *pChar3在哪里？____
ptr1在哪里？____ *ptr1在哪里？____
2. 填空题：
sizeof(num1) = ____;
sizeof(char2) = ____; strlen(char2) = ____;
sizeof(pChar3) = ____; strlen(pChar3) = ____;
sizeof(ptr1) = ____;

答案：

1. 选择题：
选项: A.栈 B.堆 C.数据段 D.代码段
globalVar在哪里？__C__ staticGlobalVar在哪里？__C__
staticVar在哪里？__C__ localVar在哪里？__A__
num1 在哪里？__A__
char2在哪里？__A__ *char2在哪里？__A_
pChar3在哪里？__A__ *pChar3在哪里？__D__
ptr1在哪里？__A__ *ptr1在哪里？_B___
2. 填空题：
sizeof(num1) = __40__;
sizeof(char2) = __5__; strlen(char2) = __4__;
sizeof(pChar3) = __4__; strlen(pChar3) = __4__;
sizeof(ptr1) = __4__;

C语言中申请内存/释放内存的方式

malloc/calloc/realloc和free

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 );
}

【面试题】
malloc/calloc/realloc的区别？

malloc只开辟空间

calloc开辟空间，并把内容初始化为0

realloc修改空间大小

1. 原地修改，如果传入的指针参数之后的空间对于申请的新空间来说足够的话，返回的还是原地址
2. 异地修改，如果传入的指针参数之后的空间对于申请的新空间来说不够的话，就会返回另外一块空间足够的起始地址。

C++申请内存/释放内存的方式

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

new/delete操作内置类型

new和delete是操作符，所以new在申请空间时不用强转

void Test()
{
// 动态申请一个int类型的空间
int* ptr4 = new int;
    
// 动态申请一个int类型的空间并初始化为10
int* ptr5 = new int(10);
    
// 动态申请10个int类型的数组空间
int* ptr6 = new int[3];
delete ptr4;
delete ptr5;
delete[] ptr6;
}

可以看到，对于内置类型，new和delete与malloc和free没有区别，只是用法不同

image-20210929143149423

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

new和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(sizeof(Test) * 10);
	free(p2);
}

void Test2()
{
	// 申请单个Test类型的对象
	Test* p1 = new Test;
	delete p1;
    
	// 申请10个Test类型的对象
	Test* p2 = new Test[10];
	delete[] p2;
}

只使用malloc/free：

只使用new/delete：

我们看到new和delete会自动调用构造函数和析构函数，而malloc和free只会开辟和释放空间。

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

并且，new对于自定义类型，可以在定义时进行初始化。

比如链表：

//单个对象
ListNode* n1 = new ListNode(5);//相当于C语言中的BuyListNode(5)

//多个对象
ListNode*n2 = new ListNode[4]{1,2,3,4};//c++11支持，C98不支持

总结：

1. C++中如果是申请内置类型变量或者数组，malloc/free和new/delete没什么区别，只是用法不同
2. 如果是自定义类型，区别很大，new和delete是开空间+初始化，析构清理+释放空间，malloc和free仅仅是开空间+释放空间。
3. 建议在C++中，无论是内置类型还是自定义类型的申请释放，尽量使用new和delete。

operator new与operator delete函数

operator new与operator delete函数

• new和delete是用户进行动态内存申请和释放的操作符，operator new 和operator delete是系统提供的
  全局函数，new在底层调用operator new全局函数来申请空间，delete在底层通过operator delete全局
  函数来释放空间
• operator new 实际也是通过malloc来申请空间，如果malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常。operator delete 最终是通过free来释放空间的
• operator new/operator delete 和malloc/free一样，只不过失败了的处理方式不同，malloc失败返回NULL，operator new失败抛异常。所以operator new就是对malloc封装了一层，空间申请失败时会抛异常

operator new对于自定义类型并不会调用自定义类型的构造函数进行初始化，operator delete同理。

所以

• new = operator new + 构造。其中，operator new又等于mallloc+失败抛异常
• delete = operator delete + 析构

operator new与operator delete的类专属重载

针对链表的节点ListNode通过重载类专属 operator new/ operator delete，实现链表节点使用内存池申请和释放内存，而不是malloc，内存池的使用可以提高效率

关于池化技术的理解：

如果我们想喝饮料，可是方圆几公里只有一家便利店，我们想喝饮料的时候就去买，如果我们频繁地有喝饮料的欲望，就会花费大量的时间在买饮料的路上。于是，我们在家里可以屯好大量的饮料，就像在一个池子里屯好了饮料，想喝的时候直接拿就行，这样就省略了花在路上的时间。以内存池为例，如果我们频繁地使用内存，就要频繁地申请，这样造成的消耗是很大的，于是可以通过池化技术来减少消耗。

new和delete的实现原理

内置类型

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

自定义类型

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

定位new表达式(placement-new)

通常我们直接为自定义类型开辟空间是没有进行初始化的，所以需要调用构造函数进行初始化，而因为构造函数是在对象产生时自动调用的，所以无法再直接使用构造函数进行初始化

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

使用格式：
new (place_address) type或者new (place_address) type(initializer-list)
place_address必须是一个指针，initializer-list是类型的初始化列表

例：

//申请空间，但没有初始化
Test*pt = (Test*)operator new(sizeof(Test));//加上初始化列表也行

//针对pt指向的这块空间调用构造函数 
new(pt)Test;//或new(pt)Test(3);

//上面两行等价于
Test*pt = new Test;//或Test*pt = new Test(3)

使用：

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类的构造函数有参数时，此处需要传参
}

可以显式调用析构函数：

pt->~Test();
operator delete(pt);

//上面两行等价于
delete pt;

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

2.复制一份数组的内容

class A {
private:
	int _a;

public:
	A(int a = 1)
		:_a(a)
	{
		cout << "构造" << endl;
	}

	A(const A& a)
	{
		this->_a = a._a;

		cout << "拷贝构造" << endl;
	}

	A& operator=(const A& a)
	{
		this->_a = a._a;
		cout << "赋值重载" << endl;

		return *this;
	}

	~A()
	{}
};

int main()
{
	A* p1 = new A[5];
	A* p2 = (A*)malloc(sizeof(A) * 5);

	for (int i = 0; i < 5; ++i)
	{
		p2[i] = p1[i];//还要调用赋值重载，消耗较大。赋值重载涉及深浅拷贝，深拷贝的影响很大
	}
	cout<<endl;
	for (int i = 0; i < 5; ++i)
	{
		new(p2 + i)A(p1[i]);//调用了拷贝构造，开销比赋值重载少
	}
	return 0;
}

常见面试题

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

如何一次在堆上申请4G的内存

// 将程序编译成x64的进程，运行下面的程序试试？
#include <iostream>
using namespace std;
int main()
{
void* p = new char[0xfffffffful];
cout << "new:" << p << endl;
return 0;
}

32位下最大才申请2GB左右的内存，那么我们换成64位就可以申请更大的内存了。

如图，4GB内存申请成功。

关于参数写成0xffffffff的原因：如果写成4 * 1024 * 1024 * 1024(2^10=1024) 的话，会超出int的范围，所以用十六进制数字0xffffffff表示4GB的大小