数据的内存分布笔记总结

原创已于 2022-05-27 22:28:51 修改 · 240 阅读

3 ·

CC 4.0 BY-SA版权

文章标签：

#c++

于 2022-05-27 22:10:18 首次发布

C++ 专栏收录该内容

29 篇文章

订阅专栏

文章目录

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);
}

选择题：
选项: A.栈 B.堆 C.数据段(静态区) D.代码段(常量区)
globalVar在哪里？____ staticGlobalVar在哪里？____
staticVar在哪里？____ localVar在哪里？____
num1 在哪里？____
char2在哪里？____ *char2在哪里？___
pChar3在哪里？____ *pChar3在哪里？____
ptr1在哪里？____ *ptr1在哪里？____
填空题：
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;
}

看看这段代码

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;
}

输出结果是这样的
在这里插入图片描述
这里说明了说明？
在申请自定义类型的空间时，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;
}

实际上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;
}

在这里插入图片描述

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在释放空间前会调用析构函数完成空间中资源的清理