new/delete和malloc/free的区别

原链接
http://blog.csdn.net/jerry4711/article/details/4620171
还是先说说区别吧：

1. new/delete是C++里才有的，而new/delete与malloc/free一个显著的区别在于，new是建造一个对象，并调用对象的构造函数来初始化对象，其实在所有的new操作过程中，总是分为两步的：第一步是申请内存，第二步则是调用构造函数初始化对象。同样，在调用delete的时候，需要先调用析构函数，然后在销毁堆内存。

2. new/delete通常来说是操作符，就是"+"，"-"一样。

3. new/delete是可以重载的，而重载之后，就成为了函数。

4. malloc在申请内存的时候，必须要提供申请的长度，而返回的指针是void*型，必须要强转才能成为需要的类型。

5. 当new/delete在类中被重载的时候，可以自定义申请过程，比如记录所申请内存的总长度，以及跟踪每个对象的指针。

6. C++默认的new/delete操作符内部，其实也调用了malloc/free这两个函数。

共同点：

1. 都必须配对使用，这里的配对使用，可不能理解为一个new/malloc就对应一个delete/free，而是指在作用域内，new/malloc所申请的内存，必须被有效释放，否则将会导致内存泄露，至于内存泄露的检查方法，我们推荐的工具是大家众所周知的BoundsChecker，至于如何使用BoundsChecker，我们将在以后撰文详解。

2. 都是申请内存，释放内存，free和delete可以释放NULL指针。

注意点：

1. new/delete与malloc/free不能混合使用，有些人对这个观点持怀疑态度，因为在很多时候，他混合使用之后也没有严重的后遗症，那是因为在通常情况下，new操作符的确调用了malloc这个函数，所以free函数可以正常的释放new出来的内存空间。但这并不能保证所有的new操作符都是调用C++的new的原始操作符，而最常见的是，在类中，我们是可以重载new这个操作符的，这样的话，如果一但在operator=new()函数中调用了其它的申请函数的话东西，free将无法正常工作，或者说也将导致内存泄露。
举几个简单的例子吧：
class CTest

{

public:

CTest();

~CTest();
private:

int* __m_pn;

};
CTest::CTest()

{

__m_pn = new int[128]; assert(__m_pn);

}
CTest::~CTest()

{

assert(__m_pn);

delete[] __m_pn;

__m_pn = NULL;

}
int main()

{

int* pn = (int*)malloc(sizeof(int));

*pn = 15;

free(pn);

pn = NULL; // 置空

free(pn); // OK，没有问题

double* pd = new double;

*pd = 212.211;

delete = pd;

short* ps = new short[128]; // new出一个数组来

ps[1] = 1231;

ps[11] = 1111;

delete[] ps; // 请注意delete的语法。

CTest* pTest = new CTest; // new出一个对象，并初始化

// …… 干活

delete pTest; // 析构，释放内存

}
// 以下是一个重载new操作符的例子，一般来说是不会用到的，除非要设计一个编译器之类的东西。

class Sample

{

public:

static CSample* operator= new()

{

CSample* p = (CSample*)malloc(size(Sample));

__m_nCount++; // 记录这个类被申请的对象的数目

return p;

}
private:

static int __m_nCount_;

};

“new”是C++的一个关键字，同时也是操作符。关于new的话题非常多，因为它确实比较复杂，也非常神秘，下面我将把我了解到的与new有关的内容做一个总结。

new 的过程

当我们使用关键字new在堆上动态创建一个对象时，它实际上做了三件事：获得一块内存空间、调用构造函数、返回正确的指针。当然，如果我们创建的是简单类型的变量，那么第二步会被省略。假如我们定义了如下一个类A：

classA

{

inti;

public:

A(int_i)
:i(_i*_i){}

voidSay() {printf("i=%d\n",i);}

};

//调用new：

A*pa
= newA(3);

那么上述动态创建一个对象的过程大致相当于以下三句话（只是大致上）：

A*pa
= (A*)malloc(sizeof(A));

pa->A::A(3);

returnpa;

虽然从效果上看，这三句话也得到了一个有效的指向堆上的A对象的指针pa，但区别在于，当malloc失败时，它不会调用分配内存失败处理程序new_handler，而使用new的话会的。因此我们还是要尽可能的使用new，除非有一些特殊的需求。

new 的三种形态

到目前为止，本文所提到的new都是指的“new operator”或称为“new expression”，但事实上在C++中一提到new，至少可能代表以下三种含义：new operator、operator new、placement new。

new operator就是我们平时所使用的new，其行为就是前面所说的三个步骤，我们不能更改它。但具体到某一步骤中的行为，如果它不满足我们的具体要求时，我们是有可能更改它的。三个步骤中最后一步只是简单的做一个指针的类型转换，没什么可说的，并且在编译出的代码中也并不需要这种转换，只是人为的认识罢了。但前两步就有些内容了。

new operator的第一步分配内存实际上是通过调用operator new来完成的，这里的new实际上是像加减乘除一样的操作符，因此也是可以重载的。operator new默认情况下首先调用分配内存的代码，尝试得到一段堆上的空间，如果成功就返回，如果失败，则转而去调用一个new_hander，然后继续重复前面过程。如果我们对这个过程不满意，就可以重载operator new，来设置我们希望的行为。例如：

classA{

public:

void*operatornew(size_tsize)

{

printf("operator
new called\n");

return
::operatornew(size);

}

};

A*a
=newA();

这里通过::operator new调用了原有的全局的new，实现了在分配内存之前输出一句话。全局的operator new也是可以重载的，但这样一来就不能再递归的使用new来分配内存，而只能使用malloc了：

void*operatornew(size_tsize)

{

printf("global
new\n");

returnmalloc(size);

}

相应的，delete也有delete operator和operator delete之分，后者也是可以重载的。并且，如果重载了operator new，就应该也相应的重载operator delete，这是良好的编程习惯。

new的第三种形态——placement new是用来实现定位构造的，因此可以实现new operator三步操作中的第二步，也就是在取得了一块可以容纳指定类型对象的内存后，在这块内存上构造一个对象，这有点类似于前面代码中的“p->A::A(3);”这句话，但这并不是一个标准的写法，正确的写法是使用placement new：

#include <new.h>

voidmain()

{

  chars[sizeof(A)];

  A*p
= (A*)s;

  new(p)A(3);//p->A::A(3);

  p->Say();

}

对头文件<new>或<new.h>的引用是必须的，这样才可以使用placement new。这里“new(p) A(3)”这种奇怪的写法便是placement new了，它实现了在指定内存地址上用指定类型的构造函数来构造一个对象的功能，后面A(3)就是对构造函数的显式调用。

这里不难发现，这块指定的地址既可以是栈，又可以是堆，placement对此不加区分。但是，除非特别必要，不要直接使用placement new ，这毕竟不是用来构造对象的正式写法，只不过是new operator的一个步骤而已。

使用new operator地编译器会自动生成对placement new的调用的代码，因此也会相应的生成使用delete时调用析构函数的代码。如果是像上面那样在栈上使用了placement new，则必须手工调用析构函数，这也是显式调用析构函数的唯一情况：

p->~A();

当我们觉得默认的new operator对内存的管理不能满足我们的需要，而希望自己手工的管理内存时，placement new就有用了。STL中的allocator就使用了这种方式，借助placement new来实现更灵活有效的内存管理。

处理内存分配异常

正如前面所说，operator new的默认行为是请求分配内存，如果成功则返回此内存地址，如果失败则调用一个new_handler，然后再重复此过程。于是，想要从operator new的执行过程中返回，则必然需要满足下列条件之一：

分配内存成功

new_handler中抛出bad_alloc异常

new_handler中调用exit()或类似的函数，使程序结束

于是，我们可以假设默认情况下operator new的行为是这样的：

void*operatornew(size_tsize)

{

void*p
= null

while(!(p
= malloc(size)))

{

if(null
== new_handler)

throwbad_alloc();

try

{

new_handler();

}

catch(bad_alloce)

{

throwe;

}

catch(…)

{}

}

returnp;

}

在默认情况下，new_handler的行为是抛出一个bad_alloc异常，因此上述循环只会执行一次。但如果我们不希望使用默认行为，可以自定义一个new_handler，并使用std::set_new_handler函数使其生效。

在自定义的new_handler中，我们可以抛出异常，可以结束程序，也可以运行一些代码使得有可能有内存被空闲出来，从而下一次分配时也许会成功，也可以通过set_new_handler来安装另一个可能更有效的new_handler。例如：

voidMyNewHandler()

{

printf(“Newhandlercalled!\n”);

throwstd::bad_alloc();

}

std::set_new_handler(MyNewHandler);

这里new_handler程序在抛出异常之前会输出一句话。应该注意，在new_handler的代码里应该注意避免再嵌套有对new的调用，因为如果这里调用new再失败的话，可能会再导致对new_handler的调用，从而导致无限递归调用。——这是我猜的，并没有尝试过。

在编程时我们应该注意到对new的调用是有可能有异常被抛出的，因此在new的代码周围应该注意保持其事务性，即不能因为调用new失败抛出异常来导致不正确的程序逻辑或数据结构的出现。例如：

classSomeClass

{

staticintcount;

SomeClass()

{}

public:

staticSomeClass*GetNewInstance()

{

count++;

returnnewSomeClass();

}

};

静态变量count用于记录此类型生成的实例的个数，在上述代码中，如果因new分配内存失败而抛出异常，那么其实例个数并没有增加，但count变量的值却已经多了一个，从而数据结构被破坏。正确的写法是：

staticSomeClass*GetNewInstance()

{

SomeClass*p
= newSomeClass();

count++;

returnp;

}

这样一来，如果new失败则直接抛出异常，count的值不会增加。类似的，在处理线程同步时，也要注意类似的问题：

voidSomeFunc()

{

lock(someMutex);//加一个锁

deletep;

p
= newSomeClass();

unlock(someMutex);

}

此时，如果new失败，unlock将不会被执行，于是不仅造成了一个指向不正确地址的指针p的存在，还将导致someMutex永远不会被解锁。这种情况是要注意避免的。（参考：C++箴言：争取异常安全的代码）