C++内存管理方式——new/delete

目录

C++内存管理方式

new/delete操作内置类型

new/delete操作自定义类型

C++保留malloc和free的原因

new、delete和malloc、free的区别

new、delete底层实现

new的三种使用方式

---

C++内存管理方式

C语言中内存管理几个常用函数是malloc、calloc、realloc和free。它们是用来在堆上开辟销毁空间的。C++作为C语言的发展，也支持malloc等这些函数，但是因为malloc、free是函数不是运算符，不在编译器控制权限之内，不能将调用构造、析构函数的任务强加给它们，因此，C++需要一个能同时完成动态内存分配和初始化工作的运算符new，以及完成清理与释放内存工作的运算符delete。

new/delete操作内置类型

在对内置类型的操作上，new/delete 与 malloc/free 几乎没有区别，只是new的写法较之malloc要简单许多：

int main()
{
	int* a = new int;
	delete a;
	return 0;
}

但是注意：C++的运算符new不会自动初始化：

 因此要初始化需要手动添加内容：

动态开辟数组：

同样不会初始化，也需要手动，用{  }

 相比于malloc，又要计算开辟字节大小，又要强制类型转化，new还是比较方便的。

new/delete操作自定义类型

对于内置类型，malloc与new几乎一样，但是对于自定义类型就有很大差别了。

new开辟空间后调用自定义类的构造函数完成初始化，delete会调用析构函数完成数据清理，然后释放空间。

class A
{
public:
	A(int a = 1)
		:_a(a)
	{
		cout << "A():" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};

int main()
{
	A* d = new A(1);
	delete d;
	return 0;
}

 

有一点一定要注意：new和delete，malloc和free，一定要匹配！！不要互相之间混用。

还有new [ ]、delete [ ] ，new、delete也要匹配！！不要出现申请数组，释放却只释放第一个指针的情况，这样很容易出问题。

以上面的A类为例，看看不匹配会怎么样

int main()
{
	A* d = new A[10];
	delete d;
	return 0;
}

 我们发现，这里只调用了一次析构函数并报错了。

但是有的编译器可能不会报错，可这不意味着我们可以不匹配，这容易造成严重问题。

以VS2013平台为例说明一下为什么会报错（不同编译器不一样，这里仅是作为参考）

开辟10个A类型对象的同时也会调用10次构造函数，那么在delete释放空间的时候编译器怎么知道我们开辟了多大的空间呢，怎么知道要调用多少次析构函数呢？（如果new和delete代码相隔很远，编译器不可能通过上下文知道）

在构造的时候，编译器会在数组头部记录下大小，也就是说如果new了10个字节空间，可能编译器开了11个，头部一个用来记录大小，delete的时候连同头部的；一起释放。

 如果不delete [ ] ，而是只delete，那么编译器默认以为你开辟的是单个空间，而不是数组，那头部必然不会存大小，因此在头部后面位置释放空间，释放位置错误也就崩溃了。

 同样的，new 和 delete[ ] 也不能这样匹配，同样会引发问题，最好配对使用。

还有的情况不会报错，比如将析构函数屏蔽，也就是让编译器自己实现析构函数。

 这是因为delete的时候没有显示写的析构函数，编译器默认自己生成，类里是内置类型析构没有什么可清理的东西，编译器就进行优化不在头部存数组大小，因此delete释放位置就没有向后偏移，完成了清理释放。

同理，如果将delete改为free释放也不会报错，因为free不会调用析构函数。但是尽量做到匹配，new对应delete，malloc对应free，不要混用！

C++保留malloc和free的原因

如此看来new和delete完全可以取代malloc和free啊，为什么C++没有这么做呢？

1、C++程序经常要调用C函数，C程序只能用malloc和free来管理动态内存，并且有些C++底层可能是用malloc和free来实现new和delete的。

2、在某些情况下，malloc和free效率高于new和delete，因此某些STL实现版本的内存分配器会采用malloc和free来进行存储管理。

new、delete和malloc、free的区别

1. malloc和free是函数，new和delete是操作符

2. malloc申请的空间不会初始化，new可以初始化

3. 申请自定义类型对象时，malloc/free只会开辟空间，不会调用构造函数与析构函数，而new在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成 空间中资源的清理

4、new和delete更加安全，new可以自动计算要构造对象的字节数量，而malloc则要自己设置字节数。new直接返回目标类型指针，不需要显示转换，而malloc返回void*，必须显示转换成目标类型才能使用。

5、我们可以自己重载new、delete，实现富有个性的内存分配和释放，而malloc和free不能重载。

6、malloc失败返回空指针，new失败抛异常

malloc失败返回空指针，new失败抛异常。

1、malloc失败返回空指针

int main()
{
	while (1)
	{
		int* a = (int*)malloc(sizeof(int)*1024*1024*100);
		if (a)
		{
			cout << a << endl;
		}
		else
		{
			cout << "malloc fail" << endl;
			break;
		}
	}
	return 0;
}

 

2、new失败抛异常

int main()
{
	try
	{
		while (1)
		{
			int* a = new int[1024*1024];
			cout << a << endl;
		}
	}
	catch (exception& e)
	{
		cout << e.what() << endl;
	}
	return 0;
}

 bad allocation说明开辟失败。

new、delete底层实现

上面说 “C++保留malloc和free的原因” 时提到了new底层是malloc实现的，delete底层是free实现的，那么具体是什么情况呢？

new是由全局函数operator new 和构造函数实现的，operator new又是由malloc实现的，注意：这里operator new不是运算符重载，而是全局函数！这个命名比较容易产生误会。

同样，delete是全局函数operator delete和析构函数实现的，Operator delete又是free实现的。

 operator new：该函数实际通过malloc来申请空间，当malloc申请空间成功时直接返回；申请空间失败，尝试执行空间不足应对措施，如果该应对措施用户设置了，则继续申请，否则抛异常。

 operator new底层实现：

void *__CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
{
 // try to allocate size bytes

 void *p;
 while ((p = malloc(size)) == 0)

        if (_callnewh(size) == 0)
     {
         // report no memory

         // 如果申请内存失败了，这里会抛出bad_alloc 类型异常

         static const std::bad_alloc nomem;
         _RAISE(nomem);
     }
 return (p);
}

operator delete底层实现：

void operator delete(void *pUserData)
{
     _CrtMemBlockHeader * pHead;
     RTCCALLBACK(_RTC_Free_hook, (pUserData, 0));
     if (pUserData == NULL)
         return;
     _mlock(_HEAP_LOCK);  /* block other threads */

     __TRY

         /* get a pointer to memory block header */

         pHead = pHdr(pUserData);
          /* verify block type */

         _ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));
         _free_dbg( pUserData, pHead->nBlockUse );
     __FINALLY

         _munlock(_HEAP_LOCK);  /* release other threads */

     __END_TRY_FINALLY

     return;
}

new的三种使用方式

一、plain new

也就是普通的new，即我们上面说的new，遵循一般规则。

二、nothrow new（很不常见）

不抛异常的new，在失败时返回空指针，使用它时不需要设置异常处理，和malloc一样检查返回值是否为空即可。

三、placement new（定位new）

允许在一块已经开辟内存的空间上构造对象或对象数组，并且它不会分配内存失败（因为它根本就不分配内存，而是只调用对象的构造函数初始化）。

 placement new的主要用途是在一块频繁使用的内存上进行构造初始化。

这也与池化技术联系到了一起。

当我们需要频繁开辟一块内存时，我们可以提前开好一块较大的内存，在上面进行构造初始化，类似内存池。

 先开好池（大块内存），再将河水（数据）送往池中，需要的时候在池中取水即可，不一定非得每次去河边打水。

对于每次从内存池来的数据，placement new就对其初始化，这就是它的用处。

在一块已经申请好的较大的内存上，使用placement new可以在上面构造不同类型的对象或者它们的数组。比如你可以先申请一块足够大的字符数组，然后用placement new在上面int类型对象或者double类型数组。

 

也可以这样使用placement new创建数组。

    //申请10个testClass类大小的动态内存

    char *buff=new char[sizeof(testClass)*10];
    memset(buff,0,sizeof(buff));
 
    //将buff的首地址赋值给一个testClass类
    testClass* start=(testClass*)buff;
 
    //循环
    for(int i=0;i<10;++i)
    {
        new (start+i)testClass(i);  //placement new一个testClass对象
        std::cout<<"class"<<i+1<<":"<<(start+i)->getData()<<std::endl;
        (start+i)->~testClass();   //使用完之后释放对象（但是动态内存仍存在）
    }
    
    //最后是释放动态内存
    delete [] buff;

需要注意的是，对于自定义类型，用placement new构造起来的对象或者数组，要显示地调用它们的析构函数（析构函数不释放对象的内存，内存依然在那里，可供后面构造的对象或数组使用），千万不能在这时候delete，因为placement new构造起来的对象或数组大小不一定等于原来分配的内存大小，因此使用delete会造成内存泄漏或在后面释放时出错。要在不再使用这块内存时，显示调用析构函数销毁对象后再delete释放空间。