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

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

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

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

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++工具箱中的一个有用工具。

在http://xll.codeplex.com上查看xll项目中的fp.h文件，它解决了喜欢随身携带维度的数组“与编译器的不必要的亲密关系”问题。

typedef struct _FP
{
    unsigned short int rows;
    unsigned short int columns;
    double array[1];        /* Actually, array[rows][columns] */
} FP;

我认为任何答案都没有强调这一点，但新位置的另一个好例子和用法是减少内存碎片(通过使用内存池)。这在嵌入式和高可用性系统中特别有用。在最后一种情况下，这一点特别重要，因为对于一个必须运行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方法分配内存在项目中基本上是被禁止的。所有的内存预留都应该到一个专用的内存池中。

我也有个主意。 c++确实有零开销原则。 但是异常不遵循这个原则，所以有时它们会被编译器开关关闭。

让我们来看看这个例子:

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

int main() {
    struct A {
        A() {
            printf("A()\n");
        }
        ~A() {
            printf("~A()\n");
        }
        char data[1000000000000000000] = {}; // some very big number
    };

    try {
        A *result = new A();
        printf("new passed: %p\n", result);
        delete result;
    } catch (std::bad_alloc) {
        printf("new failed\n");
    }
}

我们在这里分配一个大的结构体，检查分配是否成功，然后删除它。

但是如果我们关闭了异常，我们就不能使用try block，并且无法处理new[]失败。

我们怎么做呢?以下是如何做到的:

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

int main() {
    struct A {
        A() {
            printf("A()\n");
        }
        ~A() {
            printf("~A()\n");
        }
        char data[1000000000000000000] = {}; // some very big number
    };

    void *buf = malloc(sizeof(A));
    if (buf != nullptr) {
        A *result = new(buf) A();
        printf("new passed: %p\n", result);
        result->~A();
        free(result);
    } else {
        printf("new failed\n");
    }
}

使用简单的malloc 检查是否是C方式失败 如果成功了，我们就使用新位置 手动调用析构函数(不能直接调用delete) 电话免费，由于我们叫malloc

UPD @Useless写了一个注释，它向我的视图打开了new(nothrow)的存在，在这种情况下应该使用它，但不是我之前写的方法。请不要使用我之前写的代码。对不起。