C++中动态内存管理 new/delete 和new[]/delete[] 和 malloc/free

最新推荐文章于 2024-09-16 21:27:16 发布

daidaihaha

最新推荐文章于 2024-09-16 21:27:16 发布

阅读量434

点赞数

分类专栏： c++

本文链接：https://blog.csdn.net/baidu_37964044/article/details/80009739

版权

c++ 专栏收录该内容

36 篇文章 0 订阅

订阅专栏

本文介绍了C++中的动态内存管理，包括C语言中的malloc、calloc、realloc函数以及C++特有的new、new[]、delete、delete[]。对比了它们之间的区别，如malloc不进行初始化，calloc会初始化，realloc可以调整已分配内存的大小。强调了动态内存必须释放以避免内存泄漏，并探讨了C++中为何引入new/delete运算符而非仅依赖于C库的malloc和free。

摘要由CSDN通过智能技术生成

首先我们先要了解，动态内存是在堆上分配的，内存大小可以变化。动态内存的分配很好的解决了传统静态内存分配不能动态增长的缺陷（静态内存分配是在栈上，由系统自动释放）而且栈来说相对较小（为什么栈较小，假如一个函数递归死循环，会产生栈溢出，如果栈小很快就会栈溢出停下来，而如果栈很大的话，就要很久才会出错）

一 C语言中的动态内存管理

void *malloc ( size_t n)---------------向系统申请分配指定size个字节的空间如果分配成功，则返回指向被分配内存的指针。如果分配失败，将返回空指针

void* calloc （size_t num,size_t size)-----------------------num元素数量，size每个元素的长度（以字节为单位）

void* realloc（void* ptr,size_t size)--------------------------改变以前分配的内存块的大小，可以使用realloc调整以前由malloc或者calloc分配的内存（也就是改变ptr所指这个内存块的大小） 1. 如果ptr为空，相当于malloc 2.realloc不对增加的内存块进行初始化。3.如果第二个参数如果为0，则表示释放原来的空间。4.如果不能扩大内存块，就返回NULL

,而且保持原来的数据不动

总结以上三者的区别：

malloc不会对开辟的空间进行初始化。

calloc会对开辟的空间进行初始化。

realloc有三个作用1.ptr为空，相当于malloc 2.重新开空间，返回值不是ptr 3.扩容,返回值依旧是ptr

上面是动态开辟内存的

void free(void *ptr)是释放动态开辟的空间的。

注意动态开辟出来的内存，一定要释放，否则会造成内存泄漏

二 C++中动态内存分配

我们知道C++是兼容C语言的，因此在C++中我们当然可以用malloc，calloc,realloc函数来动态开辟内存，但是C++中我们还引出了new, new[],delete,delete[].但是需要注意new,delete等不是函数而是操作符。

那malloc/free和new/delete有什么区别和联系呢？

1.都可以动态管理内存

2.malloc/free是标准库的函数，new/delete是C++操作符

3.malloc/free只是动态分配空间和释放空间，而new/delete除了会分配空间还会调用构造函数和析构函数来进行初始化与清理

4.malloc/free需要手动计算类型大小且返回值为void*,new和delete可自己计算类型的大小，返回对应类型的指针注意：int char double这些内置类型有构造函数吗？C语言中没有，因为C语言中都没有构造函数这个概念。C++中有，但是不能重写。怎么证明呢？

void Test ( )
{
	int* p1 = new int;//代表动态分配，四个字节（1个int)的空间  没初始化
	int* p2 = new int ( 3 );//代表动态分配4个字节，(一个int)的空间并且初始化为3
	int* p3 = new int[3];//动态分配12个字节，（3个int)的空间   没初始化
	delete p1;
	delete p2;
	delete[] p3;

}

注意：malloc /free ,new/delete ,new[]/delete[] 一定要匹配使用，否则可能出现内存泄漏甚至崩溃的问题。为什么是可能而不是一定呢？

我们先来了解一些其他的知识然后再来更好的处理这个问题.

C++ 中其他内存接口(C++ prime中有讲到）

void* operator new(size_t size)

void operator delete(size_t size)

void* operator new[](size_t size)

void operator delete[](size_t size)

切记上面这四个函数可不是new，delete运算符的重载。怎样证明

int main ( )
{
	double *p = new double;
	//int*p = (int*)new(4);//如果是运算符重载，则说明可以这样用。但是经过验证  这样编译都通过不了，因此不是运算符的重载
	int *p1 = (int*)operator new(4);

	system ( "pause" );
	return 0;
	
}

我们发现上面这些函数和malloc和free的用法及其相似。其实C++中动态申请内存的函数是operator new 和operator new [] 有同学肯定会说动态申请不是new 吗，其实new /delete只是动态申请内存的操作符，实际上调的是operator new 和operator delete等

思考：C++既然兼容了C,那么已经有了C库的malloc和free等来动态管理内存，为什么还要new/delete运算符来动态管理内存。也就是说为什么可以调malloc和free但是却还要有new /delete去调operator new /operator delete等

回答：C语言是面向过程的语言错误返回错误码

C++是基于面向对象的语言错误要抛异常

operator new/operateor delete 是对malloc/free进行了封装

总结：1.operator new/operator delete/operator new[]/operator delete[]和malloc,free的用法一样

2.他们只负责分配释放空间，不会调用对象的构造和析构来对对象进行初始化或者资源清理

3. 其实operator new和operator delete是对malloc和free的一种封装

。。new做了两件事

1.调用operator new分配空间

2.调用构造函数初始化对象

。。delete也做了两件事

1.调用析构函数清理对象

2.调用operator delete释放空间

。。new[N]

1.调用operator new[]分配空间

2.调用N此构造函数初始化每个对象

。。delete[]

1.调用N次析构函数清理对象（思考这里的N是如何知道的）

2.调用operator delete[]释放空间

接下来我们来剖析下new/delete new[]/delete[]的底层

我们了解了new/delete new[]/delete[]的底层，接下来我们就来看为什莫new/ delete, new[]/delete[],malloc/free不匹配使用

有时会出错有时不会出错，底下我赋上详细的代码和注意解析。

class AA
{
public:
	AA ( )
	{
	
		cout << "A()" << endl;
		_a = new int[10];
	}
	/*~AA ( )
	{
		cout << "~A()" << endl;
		delete[] _a;
	}*/
	int* _a;
};
int main ( )
{
	//AA* p1 = new AA;//调构造函数和析构函数，自定义类型new创建就被初始化，delete销毁前每个对象被清理
	//delete p1;
	//free ( p1 );//不崩溃   会存在内存泄漏，掉了构造，没有调用析构，如果析构涉及对象资源清理，便会发生内存泄漏
	//delete[] p1;//崩了   越界访问
	//delete[] p1;//屏蔽析构，程序不崩溃   会发生内存泄漏
	AA* p3 = new AA[10];
	//free ( p3);//崩了   屏蔽掉析构不会崩溃   存在内存泄漏
    //delete p3;//崩了   屏蔽掉析构不会崩溃     存在内存泄漏

	//int* p4 = new int;
	//delete[] p4;//没崩


	//int* p5 = new int[10];
	//delete p5;
	//delete[]p5;
	//free ( p5 );
	/*AA* p2 = (AA*)malloc ( sizeof(AA) );
	free ( p2);*/
	system ( "pause" );
	return 0;
	
}
//class AA
//{
//public:
//	AA ( )
//	{
//		cout << "AA()" << endl;
//	}
//	~AA ( )
//	{
//		cout <<" ~AA ( )" << endl;
//	}
//
//
//};
//int main ( )
//{
//	AA* p1 = new AA;
//	delete p1;
//	AA * p2= (AA*)operator new(4);//没调构造，析构   几乎相当于malloc
//	operator delete (p2);
//	try{
//		char* p3 = (char*)operator new(0x7fffffff);
//		printf ( "%p", p3 );//抛异常
//	}
//	catch ( exception e )
//	{
//		cout << e.what ( ) << endl;
//	}
//	char* p4 = (char*) malloc(0x7fffffff);
//	printf ( "%p", p4 );   //返回错误码
//	system ( "pause" );
//	return 0;
//}
//C语言是一个面向过程的语言返回错误码
//面向对象错误抛异常   
//class AA
//{
//public:
//	AA ( )
//	{
//		cout << "AA()" << endl;
//	}
//	/*~AA ( )
//	{
//		cout << " ~AA ( )" << endl;
//	}
//*/
//private:
//	int _a;
//};
//int main ( )
//{
//	AA*p0 = new AA;
//	//free ( p0 );//没有掉析构，不会崩溃      可能会有内存泄漏
//	//delete[] p0;//出现越界  new单个对象，没有多开4个字节，delete[]会误以为p0开辟了一个数组，会让当前指针向前偏移4个字节，去取它的值。一往前偏移越界
//	
//	AA*p1 = new AA[10];
//	//free ( p1 );//崩溃  new[]会多开四个字节，free没有释放前面那四个字节
//	//delete p1;//崩溃 掉了一次析构不会导致崩溃，导致崩溃是因为没有释放前面那四个字节    掉operator delete不给多传前面那四个字节，释放错误  operator delete[]会多传前面四个字节   
//	
//	
//	//delete p1;//屏蔽掉析构，没有写，编译器会自动生成一个，编译器会识别到它的析构不会清理。编译器就不掉析构了。 当然就不用再多开那四个字节  但是如果你写了，就一定要调
//	//free(p);//屏蔽掉析构，和上面一样。
//
//	int* p2 = new int[10];
//	delete p2;//不崩溃   如果内置类型不会崩溃    不会多开四个字节，多开是为了知道后面要调多少次析构函数  int不需要调析构  因此不会崩溃
//
//	//严格来说new[]一定要多开四个字节，记录个数方便知道delete[]调几次析构函数    但是编译器会优化，编译器识别到你的构造函数可调可不掉，那就不掉了，int析构函数不会清理资源，因此就不掉了，也就不会多开四个字节
//	system ( "pause" );
//	return 0;
//}