cc++内存管理

题目

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";	// 把常量区的内容拷贝到char2数组上
	const char* pChar3 = "abcd"; 	// pChar3指针储存的时常亮字符串首元素的地址
	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);
}

选项: A.栈 B.堆 C.数据段(静态区) D.代码段(常量区)

globalVar在哪里？ C localVar在哪里? A
staticGlobalVar在哪里？C staticVar在哪里？C
num1 在哪里？A

char2在哪里？A *char2在哪里? A
pChar3在哪里？A *pChar3在哪里？D
ptr1在哪里？A *ptr1在哪里? B

c语言内存管理的方法:malloc,calloc,realloc,free

####Q:malloc/calloc/realloc的区别是什么？

A:三者都是分配内存，都是stdlib.h库里的函数，但是也存在一些差异。

malloc函数。
其原型void *malloc(unsigned int num_bytes)；
num_byte为要申请的空间大小，需要我们手动的去计算，如int *p = (int )malloc(20sizeof(int)),如果编译器默认int为4字节存储的话，那么计算结果是80Byte，一次申请一个80Byte的连续空间，并将空间基地址强制转换为int类型，赋值给指针p,此时申请的内存值是不确定的。

calloc函数
其原型void *calloc(size_t n, size_t size)；
其比malloc函数多一个参数，并不需要人为的计算空间的大小，比如如果他要申请20个int类型空间，会int *p = (int *)calloc(20, sizeof(int)）,这样就省去了人为空间计算的麻烦。但这并不是他们之间最重要的区别，malloc申请后空间的值是随机的，并没有进行初始化，而calloc却在申请后，对空间逐一进行初始化，并设置值为0;

// malloc 和 calloc
int main()
{
	int* p1 = (int*)malloc(sizeof(int) * 10);
	int* p2 = (int*)calloc(20, sizeof(int) * 10);
	cout << "malloc:" << endl;
	for (int i = 0; i < 10; ++i)
		cout << *(p1 + i) << " ";
	cout << endl;
	cout << "calloc:" << endl;
	for (int i = 0; i < 10; ++i)
		cout << *(p2 + i) << " ";
	return 0;
}

realloc函数和上面两个有本质的区别，其原型void* realloc(void *ptr, size_t new_Size)
用于对动态内存进行扩容(及已申请的动态空间不够使用，需要进行空间扩容操作)，ptr为指向原来空间基址的指针， new_size为接下来需要扩充容量的大小。

如果size较小，原来申请的动态内存后面还有空余内存，系统将直接在原内存空间后面扩容，并返回原动态空间基地址；如果size较大，原来申请的空间后面没有足够大的空间扩容，系统将重新申请一块(20+size)*sizeof(int)的内存，并把原来空间的内容拷贝过去，原来空间free;如果size非常大，系统内存申请失败，返回NULL,原来的内存不会释放。注意：如果扩容后的内存空间较原空间小，将会出现数据丢失，如果直接realloc(p, 0);相当于free§.

c++内存管理函数

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

1. 针对内置类型,new/delete和malloc/free没有本质上的区别,只有用法的区别(new/delete简化了)

2. new/delete是为自定义类型准备的.不仅是在堆上申请出来,还会调用构造和析构进行初始化和清理

3. new失败,不需要检查返回值,失败是抛异常

4. 属性的区别

   ​ new/delete：这两个是C++中的关键字，若要使用，需要编译器支持；

   ​ malloc/free：这两个是库函数，若要使用则需要引入相应的头文件才可以正常使用。

注意:new/delte, new[]/delete[]要配套使用,否则可能会出现问题

void test1()
{
	int* p1 = new int;	// 申请一个int
	int* p2 = new int(0);	// 申请一个int,并且初始化为0
	int* p3 = new int[5];	// 申请5个int的数组
	int* p4 = new int[5] {1, 2, 3};	// 初始化,c++11支持,此时数组为1,2,3,0,0
    delete p1;
    delete p2;
    delete[] p3;
    delete[] p4;
}

void test2()
{
	A* pA1 = new A();
	delete pA1;
	A* pA2 = new A(20);
	delete pA2;
	// c++ 11支持
	A* pA3 = new A[2]{ A(1), A(2) };
	delete[] pA3;
	A* pA4 = new A[2]{ 1,2 };
	delete[] pA4;
}

new和 operator new

operator new：该函数实际通过malloc来申请空间，当malloc申请空间成功时直接返回,申请空间失败，尝试执行空
间不足应对措施，如果改应对措施用户设置了，则继续申请，否则抛异常。

new和operator new之间的关系
A* a = new A；我们知道这里分为两步：
1.分配内存
2.调用A()构造对象。

事实上，分配内存这一操作就是由operator new(size_t)来完成的,如果类A重载了operator new，那么将调用A::operator new(size_t ，如果没有重载，就调用::operator new(size_t )，全局new操作符由C++默认提供。因此前面的两步也就是：

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

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

   • new 不能被重载，其行为总是一致的。它先调用operator new分配内存，然后调用构造函数初始化那段内存。

new 操作符的执行过程：

1. 调用operator new分配内存

2. 调用构造函数生成类对象；

3. 返回相应指针。

   • operator new：要实现不同的内存分配行为，应该重载operator new，而不是new。

operator new就像operator + 一样，是可以重载的。如果类中没有重载operator new，那么调用的就是全局的::operator new来完成堆的分配。同理，operator new[]、operator delete、operator delete[]也是可以重载的。

定位new表达式(placement-new)

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

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

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

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

int main()
{
	// p1现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没 有执行
	A* p1 = (A*)malloc(sizeof(A));
	new (p1) A;		// 调用构造函数
	p1->~A();	// 析构函数

	A* p2 = (A*)operator new(sizeof(A));
	new (p2) A(20);
	p2->~A();
	return 0;
}

作业

###作业标题(1040)

对于栈来讲，生长方向是向下的，也就是向着内存地址减小的方向；对于堆来讲，它的生长方向是向上的，是向着内存地址增加的方向增长

面试题

malloc/free和new/delete的区别

malloc/free和new/delete的共同点是：都是从堆上申请空间，并且需要用户手动释放。不同的地 方是：

1. malloc和free是函数，new和delete是操作符 2. malloc申请的空间不会初始化，new可以初始化 3. malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可， 如果是多个对象，[]中指定对象个数即可
2. malloc的返回值为void*, 在使用时必须强转，new不需要，因为new后跟的是空间的类型 5. malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new不需要，但是new需 要捕获异常
3. 申请自定义类型对象时，malloc/free只会开辟空间，不会调用构造函数与析构函数，而new 在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成空间中资源的清理

id*, 在使用时必须强转，new不需要，因为new后跟的是空间的类型 5. malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new不需要，但是new需 要捕获异常

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