数据的内存分布笔记总结

C/C++的内存分布

. 栈又叫堆栈，非静态局部变量/函数参数/返回值等等，栈是向下增长的
3. 堆用于程序运行时动态内存分配，堆是可以上增长的。
4. 数据段–存储全局数据和静态数据。
5. 代码段–可执行的代码/只读常量。

看一道题

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);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

1. 选择题：
   选项: A.栈 B.堆 C.数据段(静态区) D.代码段(常量区)
   globalVar在哪里？____ staticGlobalVar在哪里？____
   staticVar在哪里？____ localVar在哪里？____
   num1 在哪里？____
   char2在哪里？____ *char2在哪里？___
   pChar3在哪里？____ *pChar3在哪里？____
   ptr1在哪里？____ *ptr1在哪里？____

2. 填空题：
   sizeof(num1) = ____;
   sizeof(char2) = ____; strlen(char2) = ____;
   sizeof(pChar3) = ____; strlen(pChar3) = ____;
   sizeof(ptr1) = ____;

c语言中的malloc/calloc/realloc的区别

相同点：都是从堆区中申请空气，返回都是void*，都需要类型强转一下，失败返回NULL。
不同点：
1,malloc是开辟多少个字节的空间
2，calloc是开辟num个大小为size的元素空间，并全部初始化为0。
3，realloc在已有内存空间的基础上进行扩容，分为原地扩容和异地扩容。

C++如何管理内存？

C++中管理内存，实际上是通过new/delete，他们是关键字，不是函数
看看咋用的

int main()
{
	int* p1 = new int;  //这里是开辟1个int类型的空间
	delete p1;          //这里是删除new和delete搭配

	int* p2 = new int[5]; //开辟5个int类型的连续空间
	delete[] p2;          //new[] 和 delete 搭配使用

	int* p3 = new int(100);  //这里是给开辟的1个int类型赋值100
	cout << *p3 << endl;
	delete p3;
	 
	int* p4 = new int[5]{1,2,3,4,5};   //给开辟的连续空间赋值，如果不完全初始化，则置0
	for (int i = 0; i < 5; i++)
		cout << *(p4 + i) << endl;

	delete[] p4;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

看看这段代码

class Date
{
public:
	Date()
		:_year(2022)
	{
		cout << "Date()" << endl;
	}

	~Date()
	{
		cout << "~Date()" << endl;
		
	}
private:
	int _year;
};

void test1()
{
	Date* p1 = (Date*)malloc(sizeof(Date)); //单纯的申请1个Date类的空间，啥也不是
	Date* p2 = (Date*)malloc(sizeof(Date)*10); //单纯的连续申请10个Date类的空间，啥也不是
}

void test2()
{
	Date* p1 = new Date;  //申请一个日期类的空间
	delete p1;

	Date* p2 = new Date[5]; //申请连续的5个int类型空间
	delete[] p2;
}
int main()
{
	test1();
	test2();
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

输出结果是这样的

这里说明了说明？
在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，而malloc与free不会

operator new 和 operator delete

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

int main()
{
	int* p1 =(int*) operator new(sizeof(int));
	operator delete (p1);

	int* p2 = (int*)malloc(sizeof(int));
	free(p2);

	return 0;
}
1
2
3
4
5
6
7
8
9
10

实际上operator new / operator delete 实际上就是malloc和 free，他们用法完全一样，功能一样
都是不会去调用构造函数和析构函数的
唯一的区别就是前者开辟空间失败后抛异常，后者返回NULL

new的原理
1， 调用operator new函数申请空间
2，在申请的空间上执行构造函数，完成对象的构造

delete的原理
1， 在空间上执行析构函数，完成对象中资源的清理工作
2，调用operator delete函数释放对象的空间

new [N]的原理
1， 调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对象空间的申
请
2，在申请的空间上执行N次构造函数

delete[]的原理
1，在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理
2，调用operator delete[]释放空间，实际在operator delete[]中调用operator delete来释放空间

看看这两道题

定位new表达式

简单的说，就是用malloc申请一个类对象的空间后，然后用定位new去调用构造函数去初始化一下

class Date
{
public:
	Date()
		:_year(2022)
	{
		cout << "Date()" << endl;
	}

	~Date()
	{
		cout << "~Date()" << endl;

	}

	void Print()
	{
		cout << "hello chen" << endl;
	}
private:
	int _year;
};

int main()
{
	//仅仅是申请了一个类对象的空间，不能算一个类，因为构造函数没有执行，
	//因为我们知道当创建一个类的时候，必须要调用构造函数
	Date* p1 = (Date*)malloc(sizeof(Date));  
	
	new(p1) Date;  //定位new的用法，调用构造函数,如果构造函数要传参，这里就要传参

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

malloc/free 和 new delete的区别

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

内存泄漏

什么是内存泄漏：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。
内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，
因而造成了内存的浪费。

那这样问： 内存泄露是指针丢失还是内存丢失呢？ 显然是指针

内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会
导致响应越来越慢，最终卡死