【C++】_4.内存分布

目录

1. C/C++内存分布

2.C语言的动态内存管理方式

3.C++内存管理方式

3.1 new / delete 操作内置类型

3.2 new / delete 操作自定义类型

4.operator new 与operator delete函数

5. new 和 delete的实现原理

5.1 内置类型：

5.2 自定义类型

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

7.总结

7.1 malloc / free 与 new / delete 的区别

---

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";
	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）globalVar 存储在数据段 （2）staticGlobalVar 存储在数据段  （3）staticVar 存储在数据段 

（数据段也称静态区，存储静态变量和全局变量）

（4）localVar 存储在栈区（5）num1 存储在栈区

☆（6）char2 存储在栈区（将常量区"a b c d \0"字符串拷贝给char2）

☆（7）*char2 存储在栈区（数组名表示首元素地址，解引用得到数组首元素）  

☆（8）pchar3 存储在栈区（pchar3 是常量字符串"abcd"首字符的地址，指向常量区）

☆（9）*pchar3 存储在代码段

（代码段也成常量区，存储可执行代码和只读常量）

☆（10）ptr1 存储在栈区（局部变量存储在栈区，但ptr作为指针指向堆区动态开辟的空间）

☆（11）*ptr1 存储在堆区

2.C语言的动态内存管理方式

C语言主要通过malloc calloc realloc进行动态内存的开辟，free进行动态内存的释放：

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

对于上文代码，不需要手动free str2是因为realloc的原地扩容与异地扩容都会将扩容后的区域的起始地址返回给ptr3，只需要手动free str3即可；

C语言的动态内存管理详见：CSDN

3.C++内存管理方式

C++主要是通过new和delete操作符进行动态内存管理

3.1 new / delete 操作内置类型

    int* p1 = (int*)malloc(sizeof(int));

	int* p2 = new int;     //申请1个int的对象
	int* p3 = new int[5];  //申请5个int的数组
	int* p4 = new int(5);  //申请1个int型对象，初始化为5
	int* p5 = new int[5]{ 1,2,3 };  //C++11支持对数组进行初始化

	free(p1);

	delete p2;
	delete[] p3;
	delete p4;
	delete[] p5;

对于内置类型，new / delete 与malloc / free 没有本质区别，只有用法的区别， 

3.2 new / delete 操作自定义类型

class A
{
public:
	A(int a=0)
		:_a(a)
	{
		cout << "A(int a)" <<this<< endl;
	}
	A(const A& a)
	{
		cout << "A(const A& a)" <<this<< endl;
	}
	~A()
	{
		cout << "~A()" <<this<< endl;
	}
private:
	int _a;
};
int main()
{
	//兼容C语言
	A* p1 = (A*)malloc(sizeof(A));
	if (p1 == NULL)
	{
		perror("malloc fail");
		return 0;
	}
	free(p1);//释放空间

	//C++
	A* p2 = new A(0);
	//1.堆上申请空间 
	//2.调用默认构造函数初始化，若没有默认构造函数则需提供初始化赋值
	delete p2;
	//1.调用析构函数清理对象中的资源
	//2.释放空间

	A* p3 = new A[10];
   
	delete[] p3;
    //若要实例化多个对象，则要保证有默认构造函数；
	return 0;
}

（1）new 和 delete 是特意为自定义类型定义的动态开辟空间的，不仅在堆上申请了动态空间，还调用了构造函数初始化与析构函数进行清理操作；

（2）new、delete 和 new[ ]、 delete[ ] 一定要匹配；

（3）申请内存失败的处理方式不同：

    //malloc失败会返回空指针，打印结果为0
	char* p1 = (char*)malloc(1024u * 1024u * 1024u * 2-1);
	//cout << p1 << endl;
	//不可以cout打印，因为cout会将char* 自动识别为字符串进行打印
	printf("%p\n", p1);

	//new失败不需要检查返回值，失败会直接抛异常
	char* p2 = new char[1024u * 1024u * 1024u * 2-1];
	printf("%p\n", p2);

4.operator new 与operator delete函数

（1）调试打开反汇编发现在new进行操作时，会出现 call operator new 指令：

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

operator new: 

 

operator delete: 

实际上，operator new与operator delete底层仍然是通过malloc 与free进行动态内存空间的开辟和释放，而operator new存在的意义在于：

该函数帮助new开辟空间，不直接调用malloc可以封装malloc，为了符合C++new的失败机制：失败抛异常而非返空；

（2）opertaor new 与operator delete 也可以进行重载：

//重载一个类的专属的operator new
struct ListNode
{
	int _val;
	ListNode* _next;
	//内存池供所有ListNode使用
	static allocator<ListNode> alloc;

	//重载一个类专属的operator new 
	void* operator new(size_t n)
	{
		cout << "void operator new->STL内存池allocator申请" << endl;
		void* obj=alloc.allocate(1);
		return obj;
	}
	void operator delete(void* ptr)
	{
		cout << "operator delete->STL内存池allocator申请" << endl;
		alloc.deallocate((ListNode*)ptr,1);
	}
	struct ListNode(int val)
		:_val(val)
		,_next(nullptr)
	{ }
};
allocator<ListNode>ListNode::alloc;
int main()
{
	//频繁的申请ListNode->空间碎片
	//提高效率->申请ListNode时不去malloc而是走自己定制的内存池
	ListNode* node1 = new ListNode(1);
	ListNode* node2 = new ListNode(2);
	ListNode* node3 = new ListNode(3);
	//默认调用全局的operator new函数
	delete node1;
	delete node2;
	delete node3;
	return 0;
}

new等同于调用operator new函数+构造函数，默认情况下使用的是库中全局的operator new函数，这个函数是封装的malloc函数，但每个类都可以实现自己专属的operator new函数，此时在new一个类对象时，就会调用自己实现的operator new。

当我们频繁调用new时，会造成效率低下与空间碎片繁多，此时采取自己定义的operator new去内存池申请空间，就会提高效率。

5. new 和 delete的实现原理

5.1 内置类型：

对于内置类型，new与malloc，delete与free基本相似，不同的是：
（1）new与free申请和释放的是单个元素的空间，new[ ]和delete[ ]申请的是连续空间；

（2）new在申请空间失败时会抛异常，malloc会返回NULL；

5.2 自定义类型

（1）new的原理：

① 调用operator new函数申请空间；

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

（2）delete的原理：

① 在空间上执行析构函数，完成对象中资源的清理工作；

② 调用operator delete函数释放对象的空间；

（3）new T[N] 的原理：

① 调用operator new[ ]函数，在operator new[ ]中实际调用operator new函数完成对N个对象空间的申请；

② 在申请的空间上执行N次构造函数；

（4）delete[ ] 的原理：
① 在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理；

② 调用operator delete[ ] 释放空间，实际上在operator delete[ ] 中调用operator delete来释放空间；

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

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

使用格式：

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

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

示例：

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

int main()
{
	A* p1 = new A;
	A* p2 = (A*)malloc(sizeof(A));
	if (p2==nullptr)
	{
		perror("malloc fail");
	}
	new(p2)A;
	//new(p2)A(10);
	return 0;
}

使用场景：

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

7.总结

7.1 malloc / free 与 new / delete 的区别

（1）语法使用的区别：

① malloc / free 是函数，new / delete 是操作符；

② malloc 申请的空间不会初始化，new可以初始化；

③ malloc 申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可，如果是多个对象，在[ ]中注明对象个数即可；

④ malloc的返回值是void*，在使用时必须进行强制类型转换，new不需要，new后跟空间类型；

⑤ malloc申请空间失败时返回NULL，因此使用时必须判空，new不需要，但new需要捕获异常；

（2）本质功能的区别：

申请自定义类型对象时，malloc / free只会开辟空间不会构造函数和析构函数，而new在申请空间后调用构造函数完成对象的初始化，delete在释放完空间前会调用析构函数完成空间中资源的清理；