c++——内存管理

一. C/C++内存分布

1. 栈又叫堆栈：非静态局部变量/函数参数/返回值等等，栈是向下增长的。

2. 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口 创建共享共享内存，做进程间通信。

3. 堆用于程序运行时动态内存分配，堆是可以上增长的。

4. 数据段：存储全局数据和静态数据。

5. 代码段：可执行的代码/只读常量

6.思考：

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. 选择题：
   选项: 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或8__;     strlen(pChar3) = __4__;
   sizeof(ptr1) = __4或8__;
 

二. C++中动态内存管理

1.new操作符与delete操作符

(1) new/delete操作内置类型

void lin()
{
  // 动态申请一个int类型的空间
  int* ptr1 = new int;
  
  // 动态申请一个int类型的空间并初始化为20
  int* ptr2 = new int(20);
  
  // 动态申请20个int类型的空间
  int* ptr3 = new int[20];
  //申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用new[]和delete[]
  delete ptr1;
  delete ptr2;
  delete[] ptr3;
}

#include
using namespace std;
class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		cout << "A():" << endl;
	}
	~A()
	{
		cout << "~A():" << endl;
	}
private:
	int _a;
};
int main()
{
	// new/delete 和 malloc/free最大区别是 new/delete对于[自定义类型]除了开空间还会调用构造函数和析构函数
	A* p1 = (A*)malloc(sizeof(A));
	A* p2 = new A(1);
	free(p1);
	delete p2;
	cout << endl <<"----------" << endl;
    //在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，而malloc与free不会。
 
	// 内置类型是几乎是一样的
	int* p3 = (int*)malloc(sizeof(int)); 
	int* p4 = new int;
	free(p3);
	delete p4;
	cout << endl << "----------" << endl;
 
	return 0;
}

三. operator new与operator delete函数

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

2.operator new 实际也是通过malloc来申请空间，如果 malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施 就继续申请，否则就抛异常。operator delete 最终是通过free来释放空间的。

3. new的原理

(1). 调用operator new函数申请空间

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

4.delete的原理

(1). 在空间上执行析构函数，完成对象中资源的清理工作

(2). 调用operator delete函数释放对象的空间

5.new T[N]的原理

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

(2). 在申请的空间上执行N次构造函数

6.delete[]的原理

(1). 在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理

(2). 调用operator delete[]释放空间，实际在operator delete[]中调用operator delete来释 放空间

四. 定位new表达式(placement-new)

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

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

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

#include
using namespace std;
class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		cout << "A():"<< endl;
	}
	~A()
	{
		cout << "~A():"<< endl;
	}
private:
	int _a;
};
int main()
{
	// p1现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
	A* p1 = (A*)malloc(sizeof(A));
	new(p1)A;  // 注意：如果A类的构造函数有参数时，此处需要传参
	p1->~A();
	free(p1);
	cout <"-----" <
 
	A* p2 = (A*)operator new(sizeof(A));
	new(p2)A(10);
	p2->~A();
	operator delete(p2);
	return 0;
}