分清operator new和new operator

         在C++中new operator与operator new非一回事也，new operator（即所谓的new expression）乃语言内建，咱们是没法改变其行为的，当你写string *ps = new string("Hands up!")时，你所使用的new是所谓的new operator，它其实干了两件事：一、分配足够的内存（实际大小是大于所创建的对象大小）二、调用对象构造函数，new operator永远干这两件事。上面的那段代码大约反映以下的行为：
      void *mem = operator new(sizeof(string));
     call string::string("Hands up!") on *mem;
     string *ps = static_cast<string*>(mem);
也就是说operator new仅仅分配内存（就像malloc一样），我们能够做的仅仅是重载operator new，为自己的类创建一个定制的内存管理方案，这也让我有点明白为什么在重载operator new的时候并没有写调用构造函数的代码，但它确实被调用了，原来都是new operator搞的鬼。

 

导读： 
　　返回值类型是void*，表示其返回的是一个未经处理（raw）的指针，指向未初始化的内存。参数size_t确定分配多少内存。你能增加额外的参数重载函数operator new，但是第一个参数类型必须是size_t。头文件中有一个很好的重载的例子，那就是placement new，它看上去象这样： 
　　void * operator new(size_t, void *location) 
　　{ 
　　return location; 
　　} 
　　这初看上去有些陌生，但它却是new操作符的一种常见重载方法，使用一个额外的变量buffer，当new操作符隐含调用operator new函数时，把这个变量传递给它。被调用的operator new函数除了持有强制的参数size_t外，还必须接受void*指针参数，指向构造对象占用的内存空间。未被使用的（但是强制的）参数size_t没有参数名字，以防止编译器警告说它未被使用。在使用placement new的情况下，调用者已经获得了指向内存的指针，因为调用者知道对象应该放在哪里。placement new需要做的就是返回传递给它的指针。 
　　我们更经常使用的new是new操作符(new operator)，而非操作符new(operator new)，如当你使用new操作符构建一个对象的时候，实际上做了两件事情，一是调用operator new函数获取内存，二是调用对象的构造函数，如： 
　　string *ps = new string("Hello, world!"); 
　　它完成与下面代码相似的功能： 
　　void *memory = operator new(sizeof(string)); // 为String对象得到未经处理的内存 
　　call string::string("Hello, world!") on *memory; // 调用构造函数初始化内存中的对象 
　　string *ps = static_cast(memory); // ps指针指向新的对象 
　　注意第二步中构造函数的调用只能由编译器完成，用户是不允许这样操作的，也就是说如果你想建立一个堆对象就必须用new操作符，不能直接像上面一样调用构造函数来初始化堆对象。 
　　new操作符(new operator)是编译器内置的，其行为被语言固定下来，不受用户控制。但是它们所调用的内存分配函数也就是操作符new(operator new)则可以根据需要进行重载。试着回顾new操作符(new operator)与操作符new(operator new)的关系，如果你想在堆上建立一个对象，应该用new操作符。它既分配内存又为对象调用构造函数。如果你仅仅想分配内存，就应该调用operator new函数，它不会调用构造函数。如果你想定制自己独有的内存分配过程，你应该重载全局的operator new函数，然后使用new操作符，new操作符会调用你定制的operator new。如果你想在一块已经获得指针的内存里建立一个对象，应该使用placement new。 
　　最后需要记住的一点是，delete和new一样具有以上的特性，只是需要注意的一点是delte操作符中是首先调用对象的析构函数，然后再调用operator delete函数的。 
　　2. 针对数组的new[]和delete[]操作 
　　建立数组时new操作符(new[])的行为与单个对象建立(new)有少许不同： 
　　第一是内存不再调用用operator new函数进行分配，代替以operator new[]函数(常称作array new)。它与operator new一样能被重载，允许定制数组的内存分配，就象定制单个对象内存分配一样。 
　　第二个不同是new[]操作时调用构造函数的数量。对于new[]而言，在数组里的每一个对象的构造函数都必须被调用。 
　　delete[]操作符的语义基本上和new[]相同，他们的实现类似这样： 
　　void * operator new[](size_t size) 
　　{ 
　　cout <<"new size of array in new[](): "<　　int *g =(int *) malloc(sizeof(size)); 
　　return g; 
　　} 
　　void operator delete[](void* p) 
　　{ 
　　cout <<"delete address of array pointer in delete[](): "<

　　free(p); 
　　} 
　　3. operator new和delete函数的实现 
　　operator new实际上总是以标准的C malloc()完成，虽然并没有规定非得这么做不可。同样，operator delete也总是以标准得C free()来实现，不考虑异常处理的话他们类似下面的样子： 
　　extern void* operator new( size_t size ) 
　　{ 
　　if( size == 0 ) 
　　size = 1; // 这里保证像 new T[0] 这样得语句也是可行的 
　　 
　　void *last_alloc; 
　　while( !(last_alloc = malloc( size )) ) 
　　{ 
　　if( _new_handler ) 
　　( *_new_handler )(); 
　　else 
　　return 0; 
　　} 
　　return last_alloc; 
　　} 
　　extern void operator delete( void *ptr ) 
　　{ 
　　if(ptr) // 从这里可以看出，删除一个空指针是安全的 
　　free( (char*)ptr ); 
　　}

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/caows/archive/2007/10/30/1856098.aspx

现在知道 为什么 删除指针前要将指针指空了吧，要不然会产生悬挂指针。呵呵

C++中的operator new与new operator，看上去挺像的两姐妹，却有天壤之别。

operator new

（1） 只分配所要求的空间，不调用相关对象的构造函数。当无法满足所要求分配的空间时，则

        ->如果有new_handler，则调用new_handler，否则

        ->如果没要求不抛出异常（以nothrow参数表达），则执行bad_alloc异常，否则

        ->返回0

（2） 可以被重载

（3） 重载时，返回类型必须声明为void*

（4） 重载时，第一个参数类型必须为表达要求分配空间的大小（字节），类型为size_t

（5） 重载时，可以带其它参数

new operator

（1） 调用operator new分配足够的空间，并调用相关对象的构造函数

（2） 不可以被重载

相应地，operator delete与delete operator有相似的特性。

举个例子

class X 
{
public:
…………
    static void* operator new(size_t size)
{
    return ::operator new(size);
}
static void operator delete(void* pointee)
{
    ::operator delete(pointee);
}
…………
};
X* px = new X();


该行代码中的new为new operator，它将调用类X中的operator new，为该类的对象分配空间，然后调用当前实例的构造函数。

delete px;

该行代码中的delete为delete operator，它将调用该实例的析构函数，然后调用类X中的operator delete，以释放该实例占用的空间。

new operator与delete operator的行为是不能够也不应该被改变，这是C++标准作出的承诺。而operator new与operator delete和C语言中的malloc与free对应，只负责分配及释放空间。但使用operator new分配的空间必须使用operator delete来释放，而不能使用free，因为它们对内存使用的登记方式不同。反过来亦是一样。

你可以重载operator new和operator delete以实现对内存管理的不同要求，但你不能重载new operator或delete operator以改变它们的行为。

当重载operator new时，可以提供更多的参数，在new一个对象时，通过在关键字new后的括号传递额外的参数。比如以下的类

class A 
{
public:
    …………
    static void* operator new(size_t size, const string& example)
{
    cout << example << endl;
    return ::operator new(size);
}
…………
};
A* pa = new (“This will be printed out in operator new”) A();


新标准的C++允许以这样的方式传递一个名为nothrow的参数，以表明当为该对象分配空间失败时，不抛出异常，而是返回0，以兼容旧标准new的行为。比如

class B {};
B* pb = new (nothrow) B();


当然这只能对那些使用默认operator new操作符的类。对已经重载了operator new的类（比如上面的X和A），如果不声明能接受nothrow参数，自然无法享受C++标准带来的礼物。 

--------

我们经常看到这么一句话： operator new 可以重载， placement new 不可重载。其实此处所说的不可重载应该是指全局的 placement new 不可重载，对于类域中的 placement new 是可以重载的，而且只要重载了任何一种形式的 operator new 都应该顺便重载 placement new ， 即 void * operator new(std::size_t count, void *ptr) 。

操作符重载一般用于特定类型，名字解析过程同一般的函数重载。 Operator new 由于其特殊性，编译器提供了默认提供 6 种全局重载形式，同时还允许用户提供自定义的全局 operator new ，其参数甚至可以和全局版本一样，除全局 placement new 外。对于类域，任何形式的 new 都是可以重载的，包括 placement new 形式。

 

全局的 operator new( 函数 ) 有六种重载形式

void *operator new(std::size_t count)

    throw(std::bad_alloc);           // 一般的版本

 

void *operator new(std::size_t count,   // 兼容早版本的 new

    const std::nothrow_t&) throw();   // 内存分配失败不会抛出异常

 

void *operator new(std::size_t count, void *ptr) throw();  //placement 版本

                                      

void *operator new[](std::size_t count)  //

    throw(std::bad_alloc);

 

void *operator new[](std::size_t count,  //

    const std::nothrow_t&) throw();

 

void *operator new[](std::size_t count, void *ptr) throw();

 

重载 operator new 规则

重载 operator new 的参数个数是可以任意的 , 只需要保证第一个参数为 size_t, 返回类型为 void * 即可 , 而且其重载的参数类型也不必包含自定义类型 . 更一般的说 , operator new 的重载更像是一个函数的重载 , 而不是一个操作符的重载 . 如：

 

全局重载示例：

void* operator new(size_t size)  // 重载成功

{

   printf("global new\n");

   return malloc(size);

   //return ::operator new(size);  // 递归调用提示 (warning)

}

 

//void *operator new(std::size_t size, void *ptr) // 无法重载

//{

//     printf("global new\n");

//     return ::operator new(size,ptr);

//}

 

void * operator new(size_t size, const std::nothrow_t& e) // 重载成功 , 递归调用提示 (warning)

{

       printf("global new\n");

       return ::operator new(size, e);

}

 

一般形式的 operator new 重载示例：

void * operator new(size_t size, int x, int y, int z)

{

    ...

}

X * pX = new (1, 2, 3) X;

 

char data[1000][sizeof(foo)];

inline void* operator new(size_t size, int n)

{

        return data[n];

}

就可以使用这样有趣的语法来创建对象 :

foo *p=new(6) foo(); // 把对象创建在 data 的第六个单元上