operator new在C++中的各种写法总结

乍一看，在C++中动态分配内存很简单：new是分配，delete是释放，就这么简单。然而，这篇文章讲得要复杂一点，并且要考虑到自定义层次。这也许对简单的程序并不重要，但对你在代码中控制内存却是十分必要的，是否能写一个自定义的分配器，某种高级内存管理表或一个特定的垃圾回收机制。

这篇文章并不是一个综合的手册，而是一个C++中各种内存分配方法的概述。它面向已经很熟悉C++语言的读者。

原生operator new

我们先从原生operator new开始。考虑如下代码，它用来分配5个int型的空间并返回指向他们的指针[1]：

int* v = static_cast<int*>(::operator new(5 * sizeof(*v)));

当像如上的调用，operator new扮演原生的内存分配角色，类似malloc。上面等价于：

int* v = static_cast<int*>(malloc(5 * sizeof(*v)));

释放用operator new分配的内存用operator delete：

::operator delete(v);

你愿意永远用原生new和delete函数吗？是，只在极少数不用，我在下面的文章中会论证的。为什么用它们而不用原来的可信的malloc和free呢？一个很充分的原因就是你想保持代码在C++领域的完整性。混合使用new和free（或malloc和delete）是很不可取的（big NO NO）。用new和delete的另一个原因是你可以重载(overload)或重写(override)这些函数，只要你需要。下面是个例子：


代码如下:

void* operator new(size_t sz) throw (std::bad_alloc)
{
    cerr << "allocating " << sz << " bytesn";
    void* mem = malloc(sz);
    if (mem)
        return mem;
    else
        throw std::bad_alloc();
}

void operator delete(void* ptr) throw()
{
    cerr << "deallocating at " << ptr << endl;
    free(ptr);
}

通常，注意到new被用来给内置类型，不包含用户自定义new函数的类的对象，和任意类型的数组分配空间，使用的都是全局的运算符new。当new被用来为已经被重定义new的类实例化时，用的就是那个类的new函数。

下面来看下带new函数的类。

特定类的operator new
大家有时很好奇"operator new"和"new operator"的区别。前者可以是一个重载的operator new，全局的或者特定类或者原生的operator new。后者是你经常用来分配内存的C++内置的new operator，就像：

Car* mycar = new Car;

C++支持操作符重载，并且我们可以重载的其中一个就是new。

下面是个例子：


代码如下:

class Base
{
public:
    void* operator new(size_t sz)
    {
        cerr << "new " << sz << " bytesn";
        return ::operator new(sz);
    }

void operator delete(void* p)
    {
        cerr << "deleten";
        ::operator delete(p);
    }
private:
    int m_data;
};

class Derived : public Base
{
private:
    int m_derived_data;
    vector<int> z, y, x, w;
};

int main()
{
    Base* b = new Base;
    delete b;

Derived* d = new Derived;
    delete d;
    return 0;
}

打印结果:
new 4 bytes
delete
new 56 bytes
delete

在基类被重载的operator new和operator delete也同样被子类继承。如你所见，operator new得到了两个类的正确大小。注意实际分配内存时使用了::operator new，这是前面所描述过的原生new。在调用前面的两个冒号很关键，是为了避免进行无限递归（没有它函数将一直调用自己下去）。

为什么你要为一个类重载operator new？这里有许多理由。

性能：默认的内存分配算符被设计成通用的。有时你想分配给一个非常特殊的对象，通过自定义分配方式可以明显地提高内存管理。许多书和文章都讨论了这种情况。尤其是"Modern C++ Design"的第4章展示了一个为较小的对象的非常好的设计并实现了自定义的分配算符。

调试 & 统计：完全掌握内存的分配和释放为调试提供了很好的灵活性，统计信息和性能分析。你可将你的分配算符插入进专门用来探测缓冲区溢出的守卫，通过分配算符和释放算符(deallocations)的比较来检测内存泄漏，为统计和性能分析积累各种指标，等等。

个性化：对于非标准的内存分配方式。一个很好的例子是内存池或arenas，它们都使得内存管理变得更简单。另一个例子是某个对象的完善的垃圾回收系统，可以通过为一个类或整个层面写你自己的operators new和delete。

研究在C++中new运算符是很有帮助的。分配是分两步进行：

1.  首先，用全局operator new指导系统请求原生内存。
2.  一旦请求内存被分配，一个新的对象就在其中开始构造。

The C++ FAQ给出一个很好的例子，我很愿意在这里这出来：

当你写下这段代码：

Foo* p = new Foo();

编译器会生成类似这种功能的代码：


代码如下:

Foo* p;

// don't catch exceptions thrown by the allocator itself

//不用捕捉分配器自己抛出的异常

void* raw = operator new(sizeof(Foo));

// catch any exceptions thrown by the ctor

//捕捉ctor抛出的任何异常

try {
   p = new(raw) Foo();  // call the ctor with raw as this 像这样用raw调用ctor分配内存
 }
 catch (...) {
   // oops, ctor threw an exception 啊哦，ctor抛出了异常
   operator delete(raw);
   throw;  // rethrow the ctor's exception 重新抛出ctor的异常
 }

其中在try中很有趣的一段语法被称为"placement new"，我们马上就会讨论到。为了使讨论完整，我们来看下用delete来释放一个对象时一个相似的情况，它也是分两步进行：

1.首先，将要被删除对象的析构函数被调用。
2.然后，被对象占用的内存通过全局operator delete函数返还给系统。

所以:
delete p;
等价于[2]:
if (p != NULL) {
  p->~Foo();
  operator delete(p);
}

这时正适合我重复这篇文章第一段提到的，如果一个类有它自己的operator new或 operator delete，这些函数将被调用，而不是调用全局的函数来分配和收回内存。

Placement new
现在，回来我们上面看到样例代码中的"placement new"问题。它恰好真的能用在C++代码中的语法。首先，我想简单地解释它如何工作。然后，我们将看到它在什么时候有用。

直接调用 placement new会跳过对象分配的第一步。也就是说我们不会向操作系统请求内存。而是告诉它有一块内存用来构造对象[3]。下面的代码表明了这点：


代码如下:

int main(int argc, const char* argv[])
{
    // A "normal" allocation. Asks the OS for memory, so we
    // don't actually know where this ends up pointing.
    //一个正常的分配。向操作系统请求内存，所以我们并不知道它指向哪里
    int* iptr = new int;
    cerr << "Addr of iptr = " << iptr << endl;

// Create a buffer large enough to hold an integer, and
    // note its address.
    //创建一块足够大的缓冲区来保存一个整型，请注意它的地址
    char mem[sizeof(int)];
    cerr << "Addr of mem = " << (void*) mem << endl;

// Construct the new integer inside the buffer 'mem'.
    // The address is going to be mem's.
    //在缓冲区mem中构造新的整型，地址将变成mem的地址
    int* iptr2 = new (mem) int;
    cerr << "Addr of iptr2 = " << iptr2 << endl;

return 0;
}

在我的机器上输出如下：

Addr of iptr = 0x8679008
Addr of mem = 0xbfdd73d8
Addr of iptr2 = 0xbfdd73d8

如你所见，placement new的结构很简单。而有趣的问题是，为什么我需要用这种东西？以下显示了placement new在一些场景确实很有用：

· 自定义非侵入式内存管理。当为一个类重载 operator new 同时也允许自定义内存管理，这里关键概念是非侵入式。重载一个类的 operator new需要你改变一个类的源代码。但假设我们有一个类的代码不想或者不能更改。我们如何仍能控制它的分配呢？ Placement new就是答案。这种用 Placement new达到这个目的的通用编程技术叫做内存池，有时候也叫arenas[4]。

· 在一些程序中，在指定内存区域的分配对象是很必要的。一个例子是共享内存。另一个例子是嵌入式程序或使用内存映射的周边驱动程序，这些都可以很方便地在它们的“领地”分配对象。

· 许多容器库预先分配很大一块内存空间。当一个对象被添加，它们就必须在这里构造，因此就用上了placement new。典型的例子就是标准vector容器。

删除用placement new 分配的对象

一条C++箴言就是一个用new创建的对象应该用delete来释放。这个对placement new 同样适用吗？不完全是：


代码如下:

int main(int argc, const char* argv[])
{
    char mem[sizeof(int)];
    int* iptr2 = new (mem) int;

delete iptr2;       // Whoops, segmentation fault! 呜啊，段错误啦！

return 0;
}

为了理解上面代码片段为什么delete iptr2会引起段错误（或某种内存异常，这个因操作系统而异），让我们回想下delete iptr2实际干了什么：

1.  First, the destructor of the object that's being deleted is called.

首先，调用将要被删除的对象的析构函数。

2.  Then, the memory occupied by the object is returned to the OS, represented by the global operator delete function.

然后，这个对象在操作系统中占用的内存用全局operator delete函数收回。

对于用placement new分配的对象，第一步是没有问题的，但第二步就可疑了。尝试释放一段没有被分配算符实际分配的内存就不对了，但上面的代码确实这么做了。iptr2指向了一段并没有用全局operator new分配的栈中的一段位置。然而，delete iptr2将尝试用全局operator delete来释放内存。当然会段错误啦。

那么我们应该怎么办？我们应该怎样正确地删除iptr2？当然，我们肯定不会认为编译器怎么会解决怎么翻译内存，毕竟，我们只是传了一个指针给placement new，那个指针可能是从栈里拿，从内存池里或者别的地方。所以必须手动根据实际情况来释放。

事实上，上面的placement new用法只是C++的new指定额外参数的广义placement new语法的一种特例。它在标准头文件中定义如下：


代码如下:

inline void* operator new(std::size_t, void* __p) throw()
{
    return __p;
}

C++一个对应的带有相同参数的delete也被找到，它用来释放一个对象。它在头文件中定义如下：


代码如下:

inline void  operator delete  (void*, void*) throw()
{
}

的确，C++运行并不知道怎么释放一个对象，所以delete函数没有操作。

怎么析构呢？对于一个int，并不真的需要一个析构函数，但假设代码是这样的：
char mem[sizeof(Foo)];
Foo* fooptr = new (mem) Foo;

对于某个有意义的类Foo。我们一旦不需要fooptr了，应该怎么析构它呢？我们必须显式调用它的析构函数：
fooptr->~Foo();
对，显式调用析构函数在C++中是合法的，并且这也是唯一一种正确的做法[5]。

结论
这是一个复杂的主题，并且这篇文章只起到一个介绍的作用，对C++的多种内存分配方法给出了一种“尝鲜”。一旦你研究一些细节会发现还有许多有趣的编程技巧（例如，实现一个内存池分配）。这些问题最好是在有上下文的情况下提出，而不是作为一个普通的介绍性文章的一部分。如果你想知道得更多，请查阅下面的资源列表。

资源
· C++ FAQ Lite, especially items 11.14 and 16.9

·  "The C++ Programming Language, 3rd edition" by Bjarne Stroustrup – 10.4.11

· "Effective C++, 3rd edition" by Scott Myers – item 52

·  "Modern C++ Design" by Andrei Alexandrescu – chapter 4

· Several StackOverflow discussions. Start with this one and browse as long as your patience lasts.