分类： C/C++
2009-08-26 14:55:34
人们有时好像喜欢故意使C++语言的术语难以理解。比如说new操作符（new operator）和new操作（operator new）的区别。
当你写这样的代码：
string *ps = new string("Memory Management");
你使用的new是new操作符。这个操作符就象sizeof一样是语言内置的，你不能改变它的含义，它的功能总是一样的。它要完成的功能分成两部分。第一部分是分配足够的内存以便容纳所需类型的对象。第二部分是它调用构造函数初始化内存中的对象。new操作符总是做这两件事情，你不能以任何方式改变它的行为。
你所能改变的是如何为对象分配内存。new操作符调用一个函数来完成必需的内存分配，你能够重写或重载这个函数来改变它的行为。new操作符为分配内存所调用函数的名字是operator new。
函数operator new 通常这样声明：
void * operator new(size_t size);
返回值类型是void*，因为这个函数返回一个未经处理（raw）的指针，未初始化的内存。（如果你喜欢，你能写一种operator new函数，在返回一个指针之前能够初始化内存以存储一些数值，但是一般不这么做。）参数size_t确定分配多少内存。你能增加额外的参数重载函数operator new，但是第一个参数类型必须是size_t。（有关operator new更多的信息参见Effective C++ 条款8至条款10。）
你一般不会直接调用operator new，但是一旦这么做，你可以象调用其它函数一样调用它：
void *rawMemory = operator new(sizeof(string));
操作符operator new将返回一个指针，指向一块足够容纳一个string类型对象的内存。
就象malloc一样，operator new的职责只是分配内存。它对构造函数一无所知。operator new所了解的是内存分配。把operator new 返回的未经处理的指针传递给一个对象是new操作符的工作。当你的编译器遇见这样的语句：
string *ps = new string("Memory Management");
它生成的代码或多或少与下面的代码相似（更多的细节见Effective C++条款8和条款10，还有我的文章Counting object里的注释。）：
void *memory = // 得到未经处理的内存
operator new(sizeof(string)); // 为String对象
call string::string("Memory Management") //初始化
on *memory; // 内存中
// 的对象
string *ps = // 是ps指针指向
static_cast
注意第二步包含了构造函数的调用，你做为一个程序员被禁止这样去做。你的编译器则没有这个约束，它可以做它想做的一切。因此如果你想建立一个堆对象就必须用new操作符，不能直接调用构造函数来初始化对象。
l placement new
有时你确实想直接调用构造函数。在一个已存在的对象上调用构造函数是没有意义的，因为构造函数用来初始化对象，而一个对象仅仅能在给它初值时被初始化一次。但是有时你有一些已经被分配但是尚未处理的(raw)内存，你需要在这些内存中构造一个对象。你可以使用一个特殊的operator new ，它被称为placement new。
下面的例子是placement new如何使用，考虑一下：
class Widget {
public:
Widget(int widgetSize);
...
};
Widget * constructWidgetInBuffer(void *buffer,
int widgetSize)
{
return new (buffer) Widget(widgetSize);
}
这个函数返回一个指针，指向一个Widget对象，对象在转递给函数的buffer里分配。当程序使用共享内存或memory-mapped I/O时这个函数可能有用，因为在这样程序里对象必须被放置在一个确定地址上或一块被例程分配的内存里。（参见条款M4,一个如何使用placement new的一个不同例子。）
在constructWidgetInBuffer里面，返回的表达式是：
new (buffer) Widget(widgetSize)
这初看上去有些陌生，但是它是new操作符的一个用法，需要使用一个额外的变量（buffer），当new操作符隐含调用operator new函数时，把这个变量传递给它。被调用的operator new函数除了待有强制的参数size_t外，还必须接受void*指针参数，指向构造对象占用的内存空间。这个operator new就是placement new，它看上去象这样：
void * operator new(size_t, void *location)
{
return location;
}
这可能比你期望的要简单，但是这就是placement new需要做的事情。毕竟operator new的目的是为对象分配内存然后返回指向该内存的指针。在使用placement new的情况下，调用者已经获得了指向内存的指针，因为调用者知道对象应该放在哪里。placement new必须做的就是返回转递给它的指针。（没有用的（但是强制的）参数size_t没有名字，以防止编译器发出警告说它没有被使用；见条款M6。） placement new是标准C++库的一部分（见Effective C++ 条款49）。为了使用placement new，你必须使用语句#include
让我们从placement new回来片刻，看看new操作符（new operator）与operator new的关系，你想在堆上建立一个对象，应该用new操作符。它既分配内存又为对象调用构造函数。如果你仅仅想分配内存，就应该调用operator new函数；它不会调用构造函数。如果你想定制自己的在堆对象被建立时的内存分配过程，你应该写你自己的operator new函数，然后使用new操作符，new操作符会调用你定制的operator new。如果你想在一块已经获得指针的内存里建立一个对象，应该用placement new。
（有关更多的不同的new与delete的观点参见Effective C++ 条款7和我的文章Counting objects。）
l Deletion and Memory Deallocation
为了避免内存泄漏，每个动态内存分配必须与一个等同相反的deallocation对应。函数operator delete与delete操作符的关系与operator new与new操作符的关系一样。当你看到这些代码：
string *ps;
...
delete ps; // 使用delete 操作符
你的编译器会生成代码来析构对象并释放对象占有的内存。
Operator delete用来释放内存，它被这样声明：
void operator delete(void *memoryToBeDeallocated);
因此，
delete ps;
导致编译器生成类似于这样的代码：
ps->~string(); // call the object's dtor
operator delete(ps); // deallocate the memory
// the object occupied
这有一个隐含的意思是如果你只想处理未被初始化的内存，你应该绕过new和delete操作符，而调用operator new 获得内存和operator delete释放内存给系统：
void *buffer = // 分配足够的
operator new(50*sizeof(char)); // 内存以容纳50个char
//没有调用构造函数
...
operator delete(buffer); // 释放内存
// 没有调用析构函数
这与在C中调用malloc和free等同。
如果你用placement new在内存中建立对象，你应该避免在该内存中用delete操作符。因为delete操作符调用operator delete来释放内存，但是包含对象的内存最初不是被operator new分配的，placement new只是返回转递给它的指针。谁知道这个指针来自何方？而你应该显式调用对象的析构函数来解除构造函数的影响：
// 在共享内存中分配和释放内存的函数
void * mallocShared(size_t size);
void freeShared(void *memory);
void *sharedMemory = mallocShared(sizeof(Widget));
Widget *pw = // 如上所示,
constructWidgetInBuffer(sharedMemory, 10); // 使用
// placement new
...
delete pw; // 结果不确定! 共享内存来自
// mallocShared, 而不是operator new
pw->~Widget(); // 正确。 析构 pw指向的Widget，
// 但是没有释放
//包含Widget的内存
freeShared(pw); // 正确。 释放pw指向的共享内存
// 但是没有调用析构函数
如上例所示，如果传递给placement new的raw内存是自己动态分配的（通过一些不常用的方法），如果你希望避免内存泄漏，你必须释放它。（参见我的文章Counting objects里面关于placement delete的注释。）
l Arrays
到目前为止一切顺利，但是还得接着走。到目前为止我们所测试的都是一次建立一个对象。怎样分配数组？会发生什么？
string *ps = new string[10]; // allocate an array of
// objects
被使用的new仍然是new操作符，但是建立数组时new操作符的行为与单个对象建立有少许不同。第一是内存不再用operator new分配，代替以等同的数组分配函数，叫做operator new[]（经常被称为array new）。它与operator new一样能被重载。这就允许你控制数组的内存分配，就象你能控制单个对象内存分配一样（但是有一些限制性说明，参见Effective C++ 条款8）。
（operator new[]对于C++来说是一个比较新的东西，所以你的编译器可能不支持它。如果它不支持，无论在数组中的对象类型是什么，全局operator new将被用来给每个数组分配内存。在这样的编译器下定制数组内存分配是困难的，因为它需要重写全局operator new。这可不是一个能轻易接受的任务。缺省情况下，全局operator new处理程序中所有的动态内存分配，所以它行为的任何改变都将有深入和普遍的影响。而且全局operator new有一个正常的签名（normal signature）(也就单一的参数size_t，参见Effective C++条款9)，所以如果你决定用自己的方法声明它，你立刻使你的程序与其它库不兼容（参见条款M27）基于这些考虑，在缺乏operator new[]支持的编译器里为数组定制内存管理不是一个合理的设计。）
第二个不同是new操作符调用构造函数的数量。对于数组，在数组里的每一个对象的构造函数都必须被调用：
string *ps = // 调用operator new[]为10个
new string[10]; // string对象分配内存,
// 然后对每个数组元素调用
// string对象的缺省构造函数。
同样当delete操作符用于数组时，它为每个数组元素调用析构函数，然后调用operator delete来释放内存。
就象你能替换或重载operator delete一样，你也替换或重载operator delete[]。在它们重载的方法上有一些限制。请参考优秀的C++教材。（有关优秀的C++教材的信息，参见本书285页的推荐）
new和delete操作符是内置的，其行为不受你的控制，凡是它们调用的内存分配和释放函数则可以控制。当你想定制new和delete操作符的行为时，请记住你不能真的做到这一点。你只能改变它们为完成它们的功能所采取的方法，而它们所完成的功能则被语言固定下来，不能改变。（You can modify how they do what they do, but what they do is fixed by the language）
C++新增的异常（exception）机制改变了某些事情，这种改变是深刻的，彻底的，可能是令人不舒服的。例如：使用未经处理的或原始的指针变得很危险；资源泄漏的可能性增加了；写出具有你希望的行为的构造函数与析构函数变得更加困难。特别小心防止程序执行时突然崩溃。执行程序和库程序尺寸增加了，同时运行速度降低了。
这就使我们所知道的事情。很多使用C++的人都不知道在程序中使用异常，大多数人不知道如何正确使用它。在异常被抛出后，使软件的行为具有可预测性和可靠性，在众多方法中至今也没有一个一致的方法能做到这点。（为了深刻了解这个问题，参见Tom Cargill写的Exception Handling: A False Sense of Security。有关这些问题的进展情况的信息，参见Jack Reeves 写的Coping with Exceptions和Herb Sutter写的Exception-Safe Generic Containers。）
我们知道：程序能够在存在异常的情况下正常运行是因为它们按照要求进行了设计，而不是因为巧合。异常安全（Exception-safe）的程序不是偶然建立的。一个没有按照要求进行设计的程序在存在异常的情况下运行正常的概率与一个没有按照多线程要求进行设计的程序在多线程的环境下运行正常的概率相同，概率为0。
为什么使用异常呢？自从C语言被发明初来，C程序员就满足于使用错误代码（Error code），所以为什么还要弄来异常呢，特别是如果异常如我上面所说的那样存在着问题。答案是简单的：异常不能被忽略。如果一个函数通过设置一个状态变量或返回错误代码来表示一个异常状态，没有办法保证函数调用者将一定检测变量或测试错误代码。结果程序会从它遇到的异常状态继续运行，异常没有被捕获，程序立即会终止执行。
C程序员能够仅通过setjmp和longjmp来完成与异常处理相似的功能。但是当longjmp在C++中使用时，它存在一些缺陷，当它调整堆栈时不能对局部对象调用析构函数。（WQ加注，VC＋＋能保证这一点，但不要依赖这一点。）而大多数C＋＋程序员依赖于这些析构函数的调用，所以setjmp和longjmp不能够替换异常处理。如果你需要一个方法，能够通知不可被忽略的异常状态，并且搜索栈空间（searching the stack）以便找到异常处理代码时，你还得确保局部对象的析构函数必须被调用，这时你就需要使用C++的异常处理。
