放置new允许在已经分配的内存中构造一个对象。

当您需要构造一个对象的多个实例时，您可能需要这样做以进行优化，并且在每次需要新实例时不重新分配内存会更快。相反，对可以容纳多个对象的内存块执行一次分配可能会更有效，即使您不想一次使用所有内存块。

DevX给出了一个很好的例子:

标准c++也支持放置 New操作符，它构造 对象在预先分配的缓冲区上。这 在构建内存池时很有用， 垃圾收集器或简单的什么时候 性能和异常安全是重要的 派拉蒙(没有危险 内存分配失败 已经分配了，然后呢 对象上构造对象 预分配缓冲区占用的时间更少):

char *buf  = new char[sizeof(string)]; // pre-allocated buffer
string *p = new (buf) string("hi");    // placement new
string *q = new string("hi");          // ordinary heap allocation

您可能还希望确保在关键代码的特定部分(例如，在由起搏器执行的代码中)不存在分配失败。在这种情况下，您可能希望更早地分配内存，然后在临界区中使用placement new。

脱销在安置新

不应该释放正在使用内存缓冲区的每个对象。相反，您应该只删除[]原始缓冲区。然后必须手动调用类的析构函数。关于这方面的建议，请参阅Stroustrup的常见问题:是否存在“位置删除”?

我还有一个想法(它对c++ 11有效)。

让我们看看下面的例子:

#include <cstddef>
#include <cstdio>

int main() {
    struct alignas(0x1000) A {
        char data[0x1000];
    };

    printf("max_align_t: %zu\n", alignof(max_align_t));

    A a;
    printf("a: %p\n", &a);

    A *ptr = new A;
    printf("ptr: %p\n", ptr);
    delete ptr;
}

使用c++ 11标准，GCC给出以下输出:

max_align_t: 16
a: 0x7ffd45e6f000
ptr: 0x1fe3ec0

PTR没有正确对齐。

对于c++ 17标准和更高级的标准，GCC给出了以下输出:

max_align_t: 16
a: 0x7ffc924f6000
ptr: 0x9f6000

PTR对齐正确。

据我所知，c++标准在c++ 17之前不支持过对齐的new，如果你的结构的对齐大于max_align_t，你就会遇到问题。 要在c++ 11中绕过这个问题，可以使用aligned_alloc。

#include <cstddef>
#include <cstdlib>
#include <cstdio>
#include <new>

int main() {
    struct alignas(0x1000) A {
        char data[0x1000];
    };

    printf("max_align_t: %zu\n", alignof(max_align_t));

    A a;
    printf("a: %p\n", &a);

    void *buf = aligned_alloc(alignof(A), sizeof(A));
    if (buf == nullptr) {
        printf("aligned_alloc() failed\n");
        exit(1);
    }
    A *ptr = new(buf) A();
    printf("ptr: %p\n", ptr);
    ptr->~A();
    free(ptr);
}

在这种情况下PTR是对齐的。

max_align_t: 16
a: 0x7ffe56b57000
ptr: 0x2416000

我用它创建了一个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);

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

它可能在使用共享内存时很方便，在其他用途中…例如:http://www.boost.org/doc/libs/1_51_0/doc/html/interprocess/synchronization_mechanisms.html#interprocess.synchronization_mechanisms.conditions.conditions_anonymous_example