4.C++：内存管理

负里55

已于 2024-03-25 20:03:56 修改

阅读量508

点赞数 9

分类专栏： C++ 文章标签： c++

于 2024-03-24 13:36:40 首次发布

本文链接：https://blog.csdn.net/weixin_45930573/article/details/136969266

版权

C++ 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

一、匿名对象

int main()
{
    Solution s1;//s1的声明周期在main函数中
    s1.Sum_Solutino(10);
    
    //Solution();匿名对象，声明周期就在这一行，之后执行析构函数
    Solution().Sum_Solutino(10);//只有这一行会使用这个创建对象，别人不需要使用
    return 0；
}

二、. C/C++内存分布

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";  //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. 选择题：

选项: A.栈 B.堆 C.数据段 D.代码段

globalVar 在哪里？ __C__ staticGlobalVar 在哪里？ __C__

staticVar 在哪里？ __C__ localVar 在哪里？ ___A_

num1 在哪里？ ___A_

char2 在哪里？ __A__ * char2 在哪里？ __A_

pChar3 在哪里？ ___A_ * pChar3 在哪里？ ___D_

ptr1 在哪里？ __A__ * ptr1 在哪里？ __B__

2. 填空题：

sizeof ( num1 ) = ___40_ ;

sizeof ( char2 ) = ___5_ ; strlen ( char2 ) = __4__ ; //从元素首地址开始，遇到‘\0’结束

sizeof ( pChar3 ) = __4/8__ ; strlen ( pChar3 ) = __4__ ; //从元素首地址开始，遇到‘\0’结束

sizeof ( ptr1 ) = __4/8__ ;

三、内存管理方式

3.1C语言中动态内存管理方式

void Test ()
{
 int* p1 = (int*) malloc(sizeof(int));
 free(p1);
 // 1.malloc/calloc/realloc的区别是什么？
 int* p2 = (int*)calloc(4, sizeof (int));
 int* p3 = (int*)realloc(p2, sizeof(int)*10);
}

3.2C++内存管理方式

int main()
{
    //C 函数
    int* p1 = (int*)malloc(sizeof(int));
    int* p3 = (int*)malloc(sizeof(int)*10);
    free(p1);
    free(p3);
    //C++ 操作符
    int* p2 = new int;
    int* p4 = new int[10]; //申请10个int的40个字节空间
    int* p5 = new int(10);//申请一个int4个字节空间，初始化为10
    delete p2;
    delete[] p4;
    return 0;
}

3.3 new和delete

既然有了malloc和free，new和delete的意义何在？

1.对于内置类型，效果一样；

2.对于自定义类型，效果不一样。

class A
{
public:
	A()
	{
		_a = 0;
		cout << "A()" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};
int main()
{
	int* p1 = new int;
	int* p2 = (int*)malloc(sizeof(int));
	A* p3 = new A;  //申请空间+构造函数初始化
	A* p4 = (A*)malloc(sizeof(A)); //申请空间
    delete p3;  //析构函数+释放空间
    free(p4); //释放空间
	return 0;
}

四、operator new和operator delete

int main()
{
	A* p2 = new A;
	A* p1 = (A*)malloc(sizeof(A));
	A* p3 = (A*)operator new(sizeof(A));
	//operator new和malloc的区别是什么？
	//结论：使用方式一样，处理错误方式不一样
	size_t size = 2;
	void* p4 = malloc(size*1024*1024*1024);
	cout << p4 << endl; //失败返回0
	try
	{
		void* p5 = malloc(size * 1024 * 1024 * 1024);
		cout << p5 << endl; //失败抛异常（面向对象处理错误的方式）
	}
	catch (exception& e)
	{
		cout << e.what() << endl; 
	}
	return 0;
}

总结：

//malloc
//operator new ==>malloc+失败抛异常实现

//new ==>operator new+构造函数

new 比起malloc不一样的地方:1、调用构造函数初始化 2、失败了抛异常

delete 比起free不一样的地方:1、调用析构函数清理

operator delete 和free没有区别