【c++】内存管理(1)

要学好内存管理，首先要了解程序中内存区域的划分：

说明：

(1)栈又叫堆栈，里面存放非静态局部变量/函数参数/ 返回值等数据，栈是向下增长的；

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

(3)堆用于程序运行时动态内存分配，堆是向上增长的;

(4)数据段---存储全局数据和静态数据;

(5)代码段-可执行的代码/只读常量.

常见问题：我们对内存划分区域是为了干嘛？

答：是为了更好的管理数据。

下面来看一段代码：

#include <iostream>
using namespace std;

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";
     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); 
}
int main()
{
	Test();
	system("pause");
	return 0;
}

填空：

globalVar在数据段；      staticVar在数据段；        num1在栈 上      staticGlobalVar在数据段；                     

localVar在栈 上 ；           char2在栈上；               *char2存在栈（数组指向的内容还是在栈上）

pChar3在栈；                 *pChar 3在代码段；       ptr1在栈上；     *ptr1在堆上

计算：

#include <iostream>
using namespace std;

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";
     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); 
	 printf("%d\n", sizeof(num1)); //40
	 printf("%d\n", sizeof(char2));//5            
	 printf("%d\n", strlen(char2));//4
	 printf("%d\n", sizeof(pChar3));//4    
	 printf("%d\n", strlen(pChar3));//4
	 printf("%d\n", sizeof(ptr1));//4
}
int main()
{
	Test();
	system("pause");
	return 0;
}

计算结果：

在了解c++动态内存管理之前，先了解下c语言中的动态内存管理函数：

malloc：开辟空间，不初始化；

calloc：开辟空间，并初始化，相当于malloc+memset；

realloc：增容，既可扩容，还可缩小；

这里我写的不是很详细，想要知道更多他们区别的，可以参考：https://blog.csdn.net/qq_42270373/article/details/81735519

#include <iostream>
using namespace std;

void Test()
{
	int* p1 = (int*)malloc(sizeof (int)); 
	free(p1);
	int* p2 = (int*)calloc(4,sizeof(int)* 10);
	int* p3 = (int*)realloc(p2, sizeof(int)* 10);
	cout << p2 << endl;
	cout << p3 << endl;
	//这里不需要free(p2),因为在扩容的时候，realloc会处理的.
	free(p3);

}

int main()
{
	Test();
	system("pause");
	return 0;

在c++中，通过new和delete操作符进行动态内存管理，它的用法如下：

#include <iostream>
using namespace std;

void Test()
{
	//动态申请一个int类型的空间
	int* ptr4 = new int;
	//动态申请一个int类型的空间并初始化为10
	int* ptr5 = new int(10);
	//动态申请3个int类型的空间
	int* ptr6 = new int[3];
}

int main()
{
	Test();
	system("pause");
	return 0;
}

需要注意的是：申请和释放单个元素的空间，使用new和delete操作符，但是若是申请和释放连续的空间，则使用new[ ]和delete[ ].

通过上面代码，我们可以发现，c++的动态内存管理相比于c语言，还是有一定的优势，比如，c++中，不需要强转；不需要算字节数，给个类型，会自动算出大小；还有就是c语言中用的是函数，而c++中的new是一个操作符，不是一个函数。

c++定义new和delete和c语言中的malloc在内置类型都是一样的，都是开辟空间，但是针对于自定义类型的，new不仅开辟空间，而且还初始化，malloc是只开辟空间，并没有进行初始化。

#include <iostream>
using namespace std;

class Date
{
public:
	Date(int year=1900, int month=1, int day=1)
		:_year(year)
		, _month(month)
		, _day(day)
	{}

private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	//自定义类型
	Date* p1 = new Date;//开空间+初始化
	Date* p3 = new Date(2018, 11, 17);//开空间+初始化
	Date* p2 = (Date*)malloc(sizeof(Date));//开空间
	delete p1;//(析构)清理+释放空间
	delete(p3);
	free(p2);//释放空间
	system("pause");
	return 0;
}

调试结果：