这个问题是为了确认我对概念的理解是否正确，并就使用方式和可能的优化征求专家意见。

我试图理解“placement new”，下面是我想出的程序...

 #include <iostream>
 #include <new>

 class A {
 int *_a;
 public:
 A(int v) {std::cout<<"A c'tor clalled\n";_a= new int(v);}
 ~A() {std::cout<<"A d'tor clalled\n"; delete(_a);}
 void testFunction() {std::cout<<"I am a test function &_a = "<<_a<<" a = "<<*_a<<"\n";}
};
int main()
{
    A *obj1 = new A(21);
    std::cout<<"Object allocated at "<<obj1<<std::endl;
    obj1->~A();
    std::cout<<"Object allocated at "<<obj1<<std::endl;
    obj1->testFunction();
    A *obj2 = new(obj1) A(22);
    obj1->testFunction();
    obj2->testFunction();
    delete(obj1);// Is it really needed now? Here it will delete both objects.. so this is not the right place.
    //obj1->testFunction();
    //obj2->testFunction();
    return 0;
}

当我运行这个程序时，我得到以下 o/p

A c'tor clalled
Object allocated at 0x7f83eb404c30
A d'tor clalled
Object allocated at 0x7f83eb404c30
I am a test function &_a = 0x7f83eb404c40 a = 21
A c'tor clalled
I am a test function &_a = 0x7f83eb404c40 a = 22
I am a test function &_a = 0x7f83eb404c40 a = 22
A d'tor clalled
I am a test function &_a = 0x7f83eb404c40 a = 0
I am a test function &_a = 0x7f83eb404c40 a = 0

我有以下问题...

• 展示 placement new 的例子是否正确？
• 成员 a 是动态分配的(没有放置新的)。那么为什么它为 obj1 和 obj2 获得相同的地址。这只是巧合吗？
• D'tor 在 15 号线打电话是个好习惯吗？

还请指出您看到的任何我可以改进或只是不尝试的地方。也欢迎任何好的引用或阅读。

最佳答案

这真的非常简单:new 可以被认为是做了两件事:

1. 分配内存。
2. 放置——在分配的内存中构造对象。

不能保证 malloc 确实被实现所使用，但通常是这样。您不能对实现进行假设，但为了理解它是一个 OK 假设。

因此，以下内容被认为是等价的:

auto obj1 = new std::string("1");
// ↑ can be thought of as equivalent to ↓ 
auto obj2 = (std::string*)malloc(sizeof(std::string));
new(obj2) std::string("2");

同样适用于delete:

delete obj1;
// ↑ can be thought of as equivalent to ↓ 
obj2->~string();
free(obj2);

然后，当您看到 new 和 delete 时，您就可以轻松地推断出它们的真正含义:分配后跟构造函数调用，然后是析构函数调用释放。

当您使用放置 new 时，您已决定单独处理第一步。内存仍然必须以某种方式分配，您只需完全控制它是如何发生的以及内存从哪里来。

因此，您必须分别跟踪两件事:

1. 内存的生命周期。

2. 对象的生命周期。

下面的代码演示了它们是如何相互独立的:

#include <cstdlib>
#include <string>
#include <new>

using std::string;

int main() {
    auto obj = (string*)malloc(sizeof(string));  // memory is allocated
    new(obj) string("1");  // string("1") is constructed
    obj->~string ();       // string("1") is destructed
    new(obj) string("2");  // string("2") is constructed
    obj->~string ();       // string("2") is destructed
    free(obj);             // memory is deallocated
}

如果对象的生命周期超过内存的生命周期，你的程序就有 UB。确保内存总是比对象的生命周期长。例如，这有 UB:

void ub() {
    alignas(string) char buf[sizeof(string)]; // memory is allocated
    new(buf) string("1");                     // string("1") is constructed
} // memory is deallocated but string("1") outlives the memory!

但这没关系:

void ub() {
    alignas(string) char buf[sizeof(string)]; // memory is allocated
    new(buf) string("1");                     // string("1") is constructed
    buf->~string();                           // string("1") is destructed
}                                             // memory is deallocated

请注意您需要如何使用 alignas 正确对齐自动缓冲区.缺少任意类型的 alignas 会导致 UB。它可能看起来有效，但这只会误导您。

有一些特定的类型，不调用析构函数和不正确对齐内存不会导致 UB，但您永远不应该对类型进行此类假设。调用你的析构函数并进行对齐，如果结果是不必要的，它不会花费你任何费用 - 不会为这种类型生成额外的代码。

struct S {
  char str[10];
}

关于c++ - C++ placement new 如何工作？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/35087204/