首页 > 代码库 > 深入C++的new [转]

深入C++的new [转]

1. New的本质

使用关字new在堆上动态创建一个,它实际上做了三件事:

    ① 得一内存空

    ② 构造函数

    ③ 返回指向地址的正确指

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

 1 #include <iostream> 2 
3 4 class A { 5 int m_value; 6 public: 7 A(int value) :m_value(value * value){} 8 void Func(){ 9 std::cout<< m_value;10 }11 };12 13 int main()14 {15 A *aPtr = new A(1);16 delete *aPtr;17 system("pause");18 return 0;19 }

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

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

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

下面是 “A *a = new A(1);” 的汇编码(windows 7, Visual Studio 2008):

 1     A *aPtr = new A(1); 2 0116140D  push        4     3 0116140F  call        operator new (1161190h)   //使用new分配内存空间 4 01161414  add         esp,4  5 01161417  mov         dword ptr [ebp-0ECh],eax  6 0116141D  mov         dword ptr [ebp-4],0  7 01161424  cmp         dword ptr [ebp-0ECh],0  8 0116142B  je          main+72h (1161442h)  9 0116142D  push        1    10 0116142F  mov         ecx,dword ptr [ebp-0ECh] 11 01161435  call        A::A (1161019h)         //调用构造函数进行初始化12 0116143A  mov         dword ptr [ebp-100h],eax 13 01161440  jmp         main+7Ch (116144Ch) 14 01161442  mov         dword ptr [ebp-100h],0 15 0116144C  mov         eax,dword ptr [ebp-100h] 16 01161452  mov         dword ptr [ebp-0F8h],eax 17 01161458  mov         dword ptr [ebp-4],0FFFFFFFFh 18 0116145F  mov         ecx,dword ptr [ebp-0F8h] 19 01161465  mov         dword ptr [ebp-14h],ecx     //返回指针

下面的代码是微软对new的实现:

 1 void *__CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc) 2         {       // try to allocate size bytes 3         void *p; 4         while ((p = malloc(size)) == 0) 5                 if (_callnewh(size) == 0) 6                 {       // report no memory 7                 static const std::bad_alloc nomem; 8                 _RAISE(nomem); 9                 }10 11         return (p);12         }

可以看到,它也是调用了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这样定义:

 1 class A { 2     int m_value; 3 public: 4     A(int value) :m_value(value * value){} 5  6     void Func(){ 7         printf("m_value=%d\n", m_value); 8     } 9 10     void* operator new(size_t size){11         printf("operator new called\n");12         return ::operator new(size);13     }14 };

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

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

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

1 void* operator new(size_t size) 2 { 3   printf("global new\n"); 4   return malloc(size); 5 } 

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

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

 1 #include <iostream> 2 using namespace std; 3  4 class A { 5     int m_value; 6     static new_handler    current_handler; 7 public: 8     static new_handler set_new_handler(new_handler p){ 9         new_handler old_handler = current_handler; //保存传入的Handler,返回以前的Handler10         current_handler = p;11         return old_handler;12     }13 14     void* operator new(size_t size){15         new_handler globe_handler = std::set_new_handler(current_handler); // 调用全局函数set_new_handler设置handler16 17         void *memory = NULL;18         try{19             memory = ::operator new(size);20         }catch(std::bad_alloc){21             std::set_new_handler(globe_handler);22             throw;23         }24         std::set_new_handler(globe_handler);25 26         return memory;27     }28 29     A(int value) :m_value(value * value){}30 };31 new_handler A::current_handler = NULL;32 33 void handlerFunc(){34     cout<<"Bad Memory."<<endl;35 }36 37 int main()38 {39     A::set_new_handler(handlerFunc);40     A *aPtr = new A(1);41 42     delete aPtr;43     system("pause");44     return 0;45 }

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

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

 1 #include <iostream> 2 using namespace std; 3  4 class A { 5     int m_value; 6 public: 7     void* operator new(size_t size){ 8         cout<<"operator new."<<endl; 9         void* memory = NULL;10         memory = malloc(size);11         return memory;12     }13     A(int value) :m_value(value * value){}14 };15 16 int main()17 {18     A *aPtr = new A(1);19     ::new(aPtr) A(1);20 21     delete aPtr;22     system("pause");23     return 0;24 }

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

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

可以看到它与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)

深入C++的new [转]