[C++基础]033_深入C++的new

[C++基础]033_深入C++的new

1. New的本质

当使用关键字new在堆上动态创建一个对象时，它实际上做了三件事：

① 获得一块内存空间

② 调用类构造函数

③ 返回指向地址的正确指针

如果创建的是简单类型的变量，第二步就不执行了。下面我们看一段代码：

按 Ctrl+C 复制代码
#include <iostream>
using namespace std;

class A {
int m_value;
public:
A(int value) :m_value(value * value){}
void Func(){
printf("m_value=%d\n", m_value);
}
};

int main()
{
A *aPtr = new A(1);
delete *aPtr;
system("pause");
return 0;
}
按 Ctrl+C 复制代码

在调用 “A *a = new A(1);” 时，其过程大致如下：

A *aPtr = (A*)malloc(sizeof(A)); // 分配内存区域
aPtr->A::A(1);                   // 调用对象构造函数
return aPtr;                     // 返回内存地址指针

上面三句话表面上看起来是得到了aPtr这个指向内存的指针。但是它与new自身的区别在于，当malloc失败的时候，上面的代码不会调用分配内存失败处理程序new_handler。而使用new的话就会。因此，我们要尽可能的使用new，避免一些不必要的麻烦。

下面是 “A *a = new A(1);” 的汇编码（windows 7， Visual Studio 2008）：

A *aPtr = new A(1);
0116140D  push        4
0116140F  call        operator new (1161190h)
01161414  add         esp,4
01161417  mov         dword ptr [ebp-0ECh],eax
0116141D  mov         dword ptr [ebp-4],0
01161424  cmp         dword ptr [ebp-0ECh],0
0116142B  je          main+72h (1161442h)
0116142D  push        1
0116142F  mov         ecx,dword ptr [ebp-0ECh]
01161435  call        A::A (1161019h)
0116143A  mov         dword ptr [ebp-100h],eax
01161440  jmp         main+7Ch (116144Ch)
01161442  mov         dword ptr [ebp-100h],0
0116144C  mov         eax,dword ptr [ebp-100h]
01161452  mov         dword ptr [ebp-0F8h],eax
01161458  mov         dword ptr [ebp-4],0FFFFFFFFh
0116145F  mov         ecx,dword ptr [ebp-0F8h]
01161465  mov         dword ptr [ebp-14h],ecx

可以看出，在编译成汇编码的时候，也是先用new创建一块内存，接着调用A的构造函数初始化，最后返回内存地址的指针。下面的代码是微软对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
static const std::bad_alloc nomem;
_RAISE(nomem);
}

return (p);
}

可以看到，它也是调用了malloc函数，但是还有一些其他的处理，这就是new比malloc稍微复杂，安全的原因。

※：不同编译器的实现也是不同的，这里只是分析了微软对new的实现，至于g++及其他的实现，还未及分析。

2. New的分类

我们经常使用的new都是“new operator”和“new expression”，但事实上C++中提到的new，至少可能代表以下三种含义：new operator、operator new、placement new。

①．new operator： 我们平时使用的new，其行为如前所述的三步，事实上我们是不能更改它的行为的。

②．operator new： 从汇编码可以看出来，new operator的第一步是通过operator new完成的。这里的new就相当于一个运算符号，是可以重载的。它默认调用分配内存的代码，尝试得到一块堆上的内存空间，成功就返回；失败则调用new_handler。

■上面说到，operator new是可以重载的，下面就让我们来重载operator new试试看（严格术语上来说，应该是覆盖），我们把类A这样定义：

class A {
int m_value;
public:
A(int value) :m_value(value * value){}

void Func(){
printf("m_value=%d\n", m_value);
}

void* operator new(size_t size){
printf("operator new called\n");
return ::operator new(size);
}
};

然后执行 “A *a = new A(1);” 时，可以看到在Console里输出了一句"operator new called"，这说明operator new已经被我们重载了。这样我们就可以在分配内存前做一些我们想做的事，比如检测环境等等。

※： "::operator new(size)" 这句话的作用是调用全局的operator new，因为分配内存的操作我们一般是不用重载的。

■上面提到了全局的operator new，一般不重载，那么全局的operator new能不能被重载呢？答案是，可以。下面就让我们来重载全局的operator new来看看（严格术语上来说，应该是覆盖），在全局领域处插入如下代码：

void* operator new(size_t size)
{
printf("global new\n");
return malloc(size);
}

再次执行代码 “A *a = new A(1);” 可以看到，字符串"global new"被输出了。说明全局的operator new已经被我们重载了。当然，实际应用场景并不需要我们做这么复杂的操作。

上面我们说到过“当malloc失败的时候，上面的代码不会调用分配内存失败处理程序new_handler”，你可能会想自己定义new_handler的处理代码，事实上它是可以重载的，下面我们来重载试试看（严格术语上来说，应该是覆盖）：

#include <iostream>
using namespace std;

class A {
int m_value;
static new_handler    current_handler;
public:
static new_handler set_new_handler(new_handler p){
new_handler old_handler = current_handler; //保存传入的Handler，返回以前的Handler
current_handler = p;
return old_handler;
}

void* operator new(size_t size){
new_handler globe_handler = std::set_new_handler(current_handler); // 调用全局函数set_new_handler设置handler

void *memory = NULL;
try{
memory = ::operator new(size);
}catch(std::bad_alloc){
std::set_new_handler(globe_handler);
throw;
}
std::set_new_handler(globe_handler);

return memory;
}

A(int value) :m_value(value * value){}
};
new_handler A::current_handler = NULL;

void handlerFunc(){
cout<<"Bad Memory."<<endl;
}

int main()
{
A::set_new_handler(handlerFunc);
A *aPtr = new A(1);

delete aPtr;
system("pause");
return 0;
}

程序编译之后调试，可以看到我们的程序是可以捕获到着色代码行的异常的。这样就可以定义我们自己的异常处理函数了，比如销毁之前申请的资源等等。

③. placement new: 它的功能就相当于我们平常使用的new的本质代码的第二步——调用构造函数。下面看看它的使用方法。

#include <iostream>
using namespace std;

class A {
int m_value;
public:
void* operator new(size_t size){
cout<<"operator new."<<endl;
void* memory = NULL;
memory = malloc(size);
return memory;
}
A(int value) :m_value(value * value){}
};

int main()
{
A *aPtr = new A(1);
::new(aPtr) A(1);

delete aPtr;
system("pause");
return 0;
}

上面着色代码的第二行就是placement new的使用方法，在该行断点后，按F11，可以看到它调用的代码，如下：

inline void *__CRTDECL operator new(size_t, void *_Where) _THROW0()
{    // construct array with placement at _Where
return (_Where);
}

可以看到它与operator new的实现之间的区别，placement new有两个参数，一个传入大小，一个传入地址。而operator new的实现只有一个参数，即需要分配内存的大小。

3. 总结

①．　C++的new有三重含义：new operator、operator new、placement new。

②．　new operator是我们经常使用的new，它的内部相当于实现了三步操作：分配内存、调用构造函数、返回地址指针。

③．　operator new可以看做运算符，可以重载，重载它可以做内存分配前后的一些工作。

④．　placement new就是调用构造函数，它的书写方式比较特别：“::new(aPtr) A(1)”

参考文档

http://wenku.baidu.com/view/30709e12a21614791711284b.html

http://wenku.baidu.com/view/6b75ac81e53a580216fcfe6c.html