C++中的内存管理（上）

一、C++中的内存分布

我们先来看下下面的代码：

int globalvar = 1;
static int staticGlobalvar = 1;
void test()
{
	static int staticVar = 1;
	int localvar = 1;

	int num1[10] = { 1, 3, 2, 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);

}

关于C/C++中的内存分布大致是这样的：

1.全局变量和静态变量（static修饰的变量）存在静态区

2.常量存在常量区

3.局部变量以及const修饰的变量存在于栈中

4.使用malloc等动态开辟的内存存在于堆中

按照上面的结论，我们就知道了，globalvar是一个全局变量是存在静态区的（静态区也称为数据段），staticGlobalvar是静态变量也是全局变量，因此存在静态区中，staticVar是局部静态变量也是在静态区中，localvar是局部变量在栈空间中，num1是我们定义的数组，但不是动态开辟的因此它也是由系统自动开辟和回收的因此它也是存在于栈中，char2数组同理，*char2也是存放在栈中，pChar3同理，但是*pChar3 是被const修饰的具有常性，存放在常量区（代码段），ptr1 是一个指针变量，存放在栈空间中，*ptr1指向我们malloc出的空间，存在于堆中。

C++中的内存分布：

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

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

进程：我们先出的程序运行起来后叫做进程

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

4.数据段，又叫做静态区，存储全局数据和静态数据

5.代码段，又叫做常量区，存储可执行的代码和只读常量

二、C语言中的动态内存管理方式：malloc/calloc/realloc/free

我们来看下下面的实例代码：

void test1()
{
	//开辟4个整型大小的空间
	int* p1 = (int*)malloc(sizeof(int) * 4);
	free(p1);
	//开辟4个整型的空间然后将它们初始化成0
	int* p2 = (int*)calloc(4, sizeof(int));
	//realloc函数用来扩容，如果原来位置后面有足够空间就直接在后面扩
	//如果后面位置的内存不够，就在新开辟一块内存然后将原来的内容拷贝过去，并且realloc自动释放原来的空间
	int* p3 = (int*)realloc(p2, sizeof(int) * 10);

	//这里不需要释放p2，因为在扩容时realloc函数已经将p2给释放了
	free(p3);
}

 对于上面三种开辟函数，我在上面代码的注释了介绍了，在这里就不再多说了，下面我们来看一下C++中的内存管理方式。

三、C++中的内存管理方式

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

3.1 new/delete操作内置类型 

我们来看下面的代码：

void test()
{
	//动态申请一个int的空间
	int* ptr4 = new int;

	//动态申请一个int类型的空间并初始化为10
	int* ptr5 = new int(10);

	//动态申请6个int类型的空间
	int* ptr6 = new int[6];

	//释放空间
	delete ptr4;
	delete ptr5;
	//多个对象的释放使用delete[];
	delete[] ptr6;
}

C++中的new和delete和C中的malloc与free，除了使用方法上的区别外，其他方面基本没有区别，new申请的对象默认不会进行初始化，但是可以初始化，初始化的方法如下所示：

//单个对象的初始化
int* ptr7 = new int(11);

//多个对象的初始化
int* ptr8 = new int[3] {1, 2, 3};

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

3.2 new和delete操作自定义类型

先来看下下面的代码：

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

void test1()
{
	//new/delete 和 malloc/free 最大的区别就是 new/delete对于自定义类型除了开空间之外还会调用构造函数和析构函数
	A* p1 = (A*)malloc(sizeof(A));
	A* p2 = new A(1);
	//需要配套使用
	free(p1);
	delete p2;

	//对于内置类型基本是一样的
	int* p3 = (int*)malloc(sizeof(int));
	int* p4 = new int;

	free(p3);
	delete p4;

	A* p5 = (A*)malloc(sizeof(A) * 10);
	//调用10次构造函数
	A* p6 = new A[10];

	free(p5);
	//每个对象都调用一次析构函数
	delete[] p6;
}

int main()
{


	test1();

	return 0;
}

下面是代码运行结果：

 可以看出这里调用的次数和我们预想的是一样的。

注意：自定义类型使用malloc开辟的话无法进行初始化，new可以调用默认构造或者带参的构造函数，而且，new出的对象不是匿名对象。匿名对象的声明周期仅在它所在的那一行。

delete会析构掉那个对象，而free不会调用析构函数。