C++：内存管理

一、匿名对象

int main()
{
    Solution s1;//s1的声明周期在main函数中
    s1.Sum_Solutino(10);
    
    //Solution();匿名对象，声明周期就在这一行，之后执行析构函数
    Solution().Sum_Solutino(10);//只有这一行会使用这个创建对象，别人不需要使用
    return 0；
}

---

二、**. 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";  //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 在哪里？ 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 ; //从元素首地址开始，遇到'\0'结束
   sizeof ( pChar3 ) = 4/8 ; strlen ( pChar3 ) = 4 ; //从元素首地址开始，遇到'\0'结束
   sizeof ( ptr1 ) = 4/8 ;

---

三、内存管理方式

3.1C****语言中动态内存管理方式

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

3.2**C++**内存管理方式

int main()
{
    //C 函数
    int* p1 = (int*)malloc(sizeof(int));
    int* p3 = (int*)malloc(sizeof(int)*10);
    free(p1);
    free(p3);
    //C++ 操作符
    int* p2 = new int;
    int* p4 = new int[10]; //申请10个int的40个字节空间
    int* p5 = new int(10);//申请一个int4个字节空间，初始化为10
    delete p2;
    delete[] p4;
    return 0;
}

---

3.3 new和delete

既然有了malloc和free，new和delete的意义何在？

1.对于内置类型，效果一样；

2.对于自定义类型，效果不一样。

class A
{
public:
	A()
	{
		_a = 0;
		cout << "A()" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};
int main()
{
	int* p1 = new int;
	int* p2 = (int*)malloc(sizeof(int));
	A* p3 = new A;  //申请空间+构造函数初始化
	A* p4 = (A*)malloc(sizeof(A)); //申请空间
    delete p3;  //析构函数+释放空间
    free(p4); //释放空间
	return 0;
}

四、operator new和operator delete

int main()
{
	A* p2 = new A;
	A* p1 = (A*)malloc(sizeof(A));
	A* p3 = (A*)operator new(sizeof(A));
	//operator new和malloc的区别是什么？
	//结论：使用方式一样，处理错误方式不一样
	size_t size = 2;
	void* p4 = malloc(size*1024*1024*1024);
	cout << p4 << endl; //失败返回0
	try
	{
		void* p5 = malloc(size * 1024 * 1024 * 1024);
		cout << p5 << endl; //失败抛异常（面向对象处理错误的方式）
	}
	catch (exception& e)
	{
		cout << e.what() << endl; 
	}
	return 0;
}

总结 ：

//malloc
//operator new ==>malloc+失败抛异常实现

//new ==>operator new+构造函数

new 比起malloc不一样的地方:1、调用构造函数初始化 2、失败了抛异常

delete 比起free不一样的地方:1、调用析构函数清理

operator delete 和free没有区别

---

五、new和delete****的实现原理

5.1****内置类型

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

5.2****自定义类型

new的原理

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