我认为任何答案都没有强调这一点，但新位置的另一个好例子和用法是减少内存碎片(通过使用内存池)。这在嵌入式和高可用性系统中特别有用。在最后一种情况下，这一点特别重要，因为对于一个必须运行24/365天的系统来说，没有碎片是非常重要的。此问题与内存泄漏无关。

Even when a very good malloc implementation is used (or similar memory management function) it's very difficult to deal with fragmentation for a long time. At some point if you don't manage cleverly the memory reservation/release calls you could end up with a lot of small gaps that are difficult to reuse (assign to new reservations). So, one of the solutions that are used in this case is to use a memory pool to allocate before hand the memory for the application objects. After-wards each time you need memory for some object you just use the new placement to create a new object on the already reserved memory.

这样，一旦应用程序启动，就已经预留了所需的所有内存。所有新的内存预留/释放都将分配到已分配的池中(您可能有几个池，每个池对应一个不同的对象类)。在这种情况下不会发生内存碎片，因为没有间隙，您的系统可以运行很长时间(数年)而不会出现内存碎片。

我在实践中看到过这种情况，特别是在VxWorks RTOS中，因为它的默认内存分配系统受到了很多碎片的影响。因此，通过标准的new/malloc方法分配内存在项目中基本上是被禁止的。所有的内存预留都应该到一个专用的内存池中。

如果你想把分配和初始化分开，这是很有用的。STL使用放置new来创建容器元素。

我们将它用于自定义内存池。简单介绍一下:

class Pool {
public:
    Pool() { /* implementation details irrelevant */ };
    virtual ~Pool() { /* ditto */ };

    virtual void *allocate(size_t);
    virtual void deallocate(void *);

    static Pool *Pool::misc_pool() { return misc_pool_p; /* global MiscPool for general use */ }
};

class ClusterPool : public Pool { /* ... */ };
class FastPool : public Pool { /* ... */ };
class MapPool : public Pool { /* ... */ };
class MiscPool : public Pool { /* ... */ };

// elsewhere...

void *pnew_new(size_t size)
{
   return Pool::misc_pool()->allocate(size);
}

void *pnew_new(size_t size, Pool *pool_p)
{
   if (!pool_p) {
      return Pool::misc_pool()->allocate(size);
   }
   else {
      return pool_p->allocate(size);
   }
}

void pnew_delete(void *p)
{
   Pool *hp = Pool::find_pool(p);
   // note: if p == 0, then Pool::find_pool(p) will return 0.
   if (hp) {
      hp->deallocate(p);
   }
}

// elsewhere...

class Obj {
public:
   // misc ctors, dtors, etc.

   // just a sampling of new/del operators
   void *operator new(size_t s)             { return pnew_new(s); }
   void *operator new(size_t s, Pool *hp)   { return pnew_new(s, hp); }
   void operator delete(void *dp)           { pnew_delete(dp); }
   void operator delete(void *dp, Pool*)    { pnew_delete(dp); }

   void *operator new[](size_t s)           { return pnew_new(s); }
   void *operator new[](size_t s, Pool* hp) { return pnew_new(s, hp); }
   void operator delete[](void *dp)         { pnew_delete(dp); }
   void operator delete[](void *dp, Pool*)  { pnew_delete(dp); }
};

// elsewhere...

ClusterPool *cp = new ClusterPool(arg1, arg2, ...);

Obj *new_obj = new (cp) Obj(arg_a, arg_b, ...);

现在你可以将对象聚集在一个单独的内存区域中，选择一个非常快但不进行释放的分配器，使用内存映射，以及任何你希望通过选择池并将其作为参数传递给对象的放置new操作符来施加的语义。

我用它来存储带有内存映射文件的对象。 具体的例子是一个图像数据库，它处理大量的大图像(超过内存容量)。

在序列化时(比如使用boost::serialization)，放置new也非常有用。在c++的10年里，这只是我第二次需要新职位的情况(如果你包括面试的话，这是第三次:))。

我在实时编程中使用过它。我们通常不希望在系统启动后执行任何动态分配(或重新分配)，因为无法保证这将花费多长时间。

我能做的是预先分配一大块内存(大到足以容纳类可能需要的任何数量)。然后，一旦我在运行时弄清楚如何构造这些东西，就可以在我想要的地方使用放置new来构造对象。我知道我使用它的一种情况是帮助创建异构循环缓冲区。

这当然不适合胆小的人，但这就是为什么他们把它的语法弄得有点粗糙。