Malloc 和构造函数

Question

与 new 和 delete 表达式不同，std::malloc 在分配对象内存时不会调用构造函数。那么，我们如何创建一个对象，以便构造函数也被调用呢？

Answer 1

呃...使用new？这就是重点。您也可以显式调用构造函数，但没有什么理由这样做

正常使用 new/delete：

A* a = new A();

delete a;

显式调用构造函数/析构函数 ("新展示位置")：

A* a = (A*)malloc(sizeof(A));
new (a) A();

a->~A();
free(a);

Answer 2

如果您确实需要，可以使用“placement new”语法来做到这一点：

MyClassName* foo = new(pointer) MyClassName();

其中 pointer 是一个指针分配到足够大以容纳对象实例的已分配内存位置。

Answer 3

更喜欢新的。

但是，如果由于某种原因你有原始内存，你可以用“placement new”来构造它：

new (ptr) TYPE(args);

并且由于你不会使用删除，所以你需要直接调用析构函数：

ptr->~TYPE();

Answer 4

看一下放置新运算符，它在预先分配的缓冲区上构造一个对象。

Answer 5

您误解了 malloc 的作用。 malloc 不创建对象，它分配内存。由于它不创建对象，因此没有对象可供它调用构造函数来创建。

如果需要在 C++ 中动态创建对象，则需要使用某种形式的 new。

Answer 6

这个问题的答案随着时间的推移而不断变化，因此这里有一个更新的答案：

malloc 只是为对象分配存储空间。以下代码在 C 中有效，但在 C++ 中可能无效：

T* object = (T*) malloc(sizeof(T));
*object = ...;

在 C 中，写入 *object 隐式开始 T 对象的生命周期，这是由malloc分配的内存。

在 C++ 中，*object = 将在对象的生命周期尚未开始时尝试写入该对象。这种未定义的行为。但是，如果 T 是 隐式生命周期类型，此代码定义明确 (C++20 起)：

[malloc、calloc 和 realloc] 隐式创建对象 ([intro.object]) 在返回的存储区域中，并返回指向合适的已创建对象的指针。
对于calloc 和realloc，对象分别在存储清零或复制之前创建。

- [c.malloc] §5

C++98 - C++17

在 C++20 之前，唯一合法的解决方案是使用 placement-new：

auto object = reinterpret_cast<T>(std::malloc(sizeof(T));) // allocate storage
object = new (object) T(arg0, arg1, ...);                  // begin lifetime

do_something_with(*object);

object->~T();                                              // end lifetime
std::free(object);                                         // de-allocate storage

请注意，我们将 new 表达式的结果分配给 object。如果我们不这样做，编译器将被允许假设 object 仍然指向 std::malloc 中的未初始化内存！通过 object 访问对象将是未定义的行为，或者我们必须使用 std::launder。

C++20

C++20 添加了两个比placement-new 更好的函数。它们可以在编译时使用，并且像常规函数一样使用：

auto object = reinterpret_cast<T>(std::malloc(sizeof(T));) // allocate storage
object = std::construct_at(object, arg0, arg1, ...);       // begin lifetime

do_something_with(*object);

std::destroy_at(object);                                   // end lifetime
std::free(object);                                         // de-allocate storage

感谢 std::construct_at 和 std:: destroy_at 后，我们不再在三个不同的地方重复类型 T。它是从函数参数推导出来的，这要好得多。

注意：如上所述，只有当我们的类型不是 时，我们才需要这些函数隐式生命周期类型，例如初始化std::string时。开头所示的 C 代码就是一个有效的示例，尽管您应该更喜欢 C++ 中的 reinterpret_cast 和 std::malloc。

C++23

< code>std::malloc 隐式创建一个对象，因为它被标准特殊对待。但是，如果我们想实现自己的 malloc 函数，我们将无法从中受益。 C++23 引入了显式生命周期管理 来解决这个问题。

始终使用 std::construct_at 也是不可行的，因为它对存储进行值初始化，即我们无法创建在写入之前保持未初始化的缓冲区。

仅适用于隐式生命周期类型的解决方案 C++23 如下所示：

auto object = reinterpret_cast<T>(my_malloc(sizeof(T));)      // allocate storage
object = std::start_lifetime_as<T>(object, arg0, arg1, ...);  // begin lifetime

do_something_with(*object);

// no need to explicitly end lifetime
my_free(object);                                              // de-allocate storage

注意：隐式生命周期类型 总是容易被破坏，这就是为什么我们可以省略 std::destroy_at< /code>.

Answer 7

使用新展示位置 。这个建议很方便：

建议：请勿使用此“新展示位置”
语法，除非你必须这样做。仅使用它
当你真正关心一个物体时
放置在特定位置
记忆。例如，当您的
硬件有一个内存映射 I/O 定时器
设备，并且您想要放置一个时钟
该内存位置的对象。

Answer 8

class A
{
    public:
      A() { printf("Constructor of A"); }
};

int main()
{
   A* pA = (A*) malloc(sizeof(A));  // Construtor is not going to be called.

   __asm { MOV EAX, pA}             // Makes pA as "this" pointer in intel based s/m.

   A();                             // Calling constructor explicitly.

   return 0;
}