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

这里是c++ in-place构造函数的杀手级用法:对齐缓存线，以及其他2边界的幂。以下是我的超快速指针对齐算法，使用5个或更少的单周期指令，达到2边界的任意幂:

/* Quickly aligns the given pointer to a power of two boundary IN BYTES.
@return An aligned pointer of typename T.
@brief Algorithm is a 2's compliment trick that works by masking off
the desired number in 2's compliment and adding them to the
pointer.
@param pointer The pointer to align.
@param boundary_byte_count The boundary byte count that must be an even
power of 2.
@warning Function does not check if the boundary is a power of 2! */
template <typename T = char>
inline T* AlignUp(void* pointer, uintptr_t boundary_byte_count) {
  uintptr_t value = reinterpret_cast<uintptr_t>(pointer);
  value += (((~value) + 1) & (boundary_byte_count - 1));
  return reinterpret_cast<T*>(value);
}

struct Foo { Foo () {} };
char buffer[sizeof (Foo) + 64];
Foo* foo = new (AlignUp<Foo> (buffer, 64)) Foo ();

这是不是让你的脸上露出了微笑(:)。我♥♥♥c++ 1x

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

我用它创建了一个Variant类(例如，一个对象可以表示一个单独的值，这个值可以是许多不同类型中的一个)。

如果Variant类支持的所有值类型都是POD类型(例如int, float, double, bool)，那么带标签的C风格的联合就足够了，但如果你想要一些值类型是c++对象(例如std::string)， C的联合特性就不行，因为非POD数据类型可能不会被声明为联合的一部分。

因此，我分配了一个足够大的字节数组(例如sizeof(the_largest_data_type_I_support))，并使用placement new在该区域初始化适当的c++对象，当Variant被设置为持有该类型的值时。(当然，当切换到不同的数据类型时，我事先手动调用对象的析构函数)

实际上，实现任何类型的数据结构都需要分配比插入元素数量的最低要求更多的内存(即，除了每次分配一个节点的链接结构之外的任何数据结构)。

以unordered_map、vector或deque等容器为例。这些都为您插入的元素分配了比最低要求更多的内存，以避免为每次插入都需要堆分配。让我们用向量作为最简单的例子。

当你这样做时:

vector<Foo> vec;

// Allocate memory for a thousand Foos:
vec.reserve(1000);

．.． 其实也造不出一千个foo。它只是为它们分配/保留内存。如果vector没有在这里使用放置new，它将在所有地方默认构造foo，并且必须调用它们的析构函数，即使是对于你从未在第一个位置插入的元素。

分配=建设，解放=毁灭

一般来说，要实现像上面这样的许多数据结构，不能将分配内存和构造元素视为一个不可分割的事情，同样也不能将释放内存和销毁元素视为一个不可分割的事情。

为了避免不必要地向左或向右调用多余的构造函数和析构函数，这就是标准库将std::allocator(在分配/释放内存*时不构造或销毁元素)的思想与使用它的容器分开的原因，这些容器使用放置new手动构造元素，使用显式调用析构函数手动销毁元素。

我讨厌std::allocator的设计，但这是一个不同的主题，我将避免咆哮。: - d

So anyway, I tend to use it a lot since I've written a number of general-purpose standard-compliant C++ containers that could not be built in terms of the existing ones. Included among them is a small vector implementation I built a couple decades ago to avoid heap allocations in common cases, and a memory-efficient trie (doesn't allocate one node at a time). In both cases I couldn't really implement them using the existing containers, and so I had to use placement new to avoid superfluously invoking constructors and destructors on things unnecessary left and right.

当然，如果你曾经使用自定义分配器来单独分配对象，比如一个free list，那么你通常也会想使用placement new，就像这样(基本的例子，不需要担心异常安全或RAII):

Foo* foo = new(free_list.allocate()) Foo(...);
...
foo->~Foo();
free_list.free(foo);

The one place I've run across it is in containers which allocate a contiguous buffer and then fill it with objects as required. As mentioned, std::vector might do this, and I know some versions of MFC CArray and/or CList did this (because that's where I first ran across it). The buffer over-allocation method is a very useful optimization, and placement new is pretty much the only way to construct objects in that scenario. It is also used sometimes to construct objects in memory blocks allocated outside of your direct code.

我在类似的情况下使用过它，尽管它不经常出现。不过，它是c++工具箱中的一个有用工具。