A Za, A Za, Fighting...

　　在这里顺便对条件编译（#ifdef, #else, #endif, #if等）进行说明。以下分3种情况：

　　1. 情况1：
　　#ifdef _XXXX
　　    ...程序段1...
　　#else
　　    ...程序段2...
　　#endif
　　这表明如果标识符_XXXX已被#define命令定义过则对程序段1进行编译；否则对程序段2进行编译。

　　2:情况2：
　　#ifndef _XXXX
　　    ...程序段1...
　　#else
　　    ...程序段2...
　　#endif
　　这里使用了#ifndef，表示的是if not def。当然是和#ifdef相反的状况（如果没有定义了标识符_XXXX，那么执行程序段1，否则执行程序段2）。

　　3：情况3：
　　#if 常量
　　    ...程序段1...
      #else
　　    ...程序段2...
　　#endif
　　这里表示，如果常量为真（非0，随便什么数字，只要不是0），就执行程序段1，否则执行程序段2。

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 的第六个单元上