Malloc and constructors

Question

Unlike new and delete expressions, std::malloc does not call the constructor when memory for an object is allocated. In that case, how must we create an object so that the constructor will also be called?

Answer 1

Er...use new? That's kind of the point. You can also call the constructor explicitly, but there's little reason to do it that way

Using new/delete normally:

A* a = new A();

delete a;

Calling the constructor/destructor explicitly ("placement new"):

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

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

Answer 2

You can use "placement new" syntax to do that if you really, really need to:

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

where pointer is a pointer to an allocated memory location large enough to hold an instance of your object.

Answer 3

Prefer new.

But if for some reason you have raw memory, you can construct it with "placement new":

new (ptr) TYPE(args);

And since you won't be using delete, you'll need to call the destructor directly:

ptr->~TYPE();

Answer 4

Take a look at placement new operator, which constructs an object on a pre-allocated buffer.

Answer 5

You mis-understand what malloc does. malloc does not create objects, it allocates memory. As it does not create objects there is no object for it to call a constructor to create.

If you need to dynamically create an object in C++ you need to use some form of new.

Answer 6

Use placement new. The advice is handy:

ADVICE: Don't use this "placement new" syntax unless you have to. Use it only when you really care that an object is placed at a particular location in memory. For example, when your hardware has a memory-mapped I/O timer device, and you want to place a Clock object at that memory location.

Answer 7

The answer to this question has evolved over time, so here's an updated answer:

malloc merely allocates storage for an object. The following code works in C, but might not in C++:

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

In C, writing to *object implicitly begins the lifetime of a T object, which is a special property of the memory allocated by malloc.

In C++, *object = would attempt to write to the object when its lifetime hasn't begun. This undefined behavior. However, if T is an implicit-lifetime type, this code is well-defined (since C++20):

[malloc, calloc, and realloc] implicitly create objects ([intro.object]) in the returned region of storage and return a pointer to a suitable created object. In the case of calloc and realloc, the objects are created before the storage is zeroed or copied, respectively.

- [c.malloc] §5

C++98 - C++17

Before C++20, the only legal solution would be to use 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

Pay attention to the fact that we are assigning the result of the new expression to object. If we didn't do that, the compiler would be allowed to assume that object is still pointing to unitialized memory from std::malloc! Accessing the object through object would be undefined behavior, or we would have to use std::launder.

C++20

C++20 has added two functions which are preferable to placement-new. They can be used at compile time, and they are used like regular functions:

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

Thanks to std::construct_at and std::destroy_at, we are no longer repeating the type T in three different places. It is deduced from the function arguments, which is much nicer.

Note: as explained above, we only need these functions if our type is not an implicit-lifetime type, e.g. when initializing std::string. The C code shown in the beginning is a working example of this, although you should prefer reinterpret_cast and std::malloc in C++.

C++23

std::malloc implicitly creates an object because it is treated specially by the standard. However, if we wanted to implement our own malloc function, we wouldn't benefit from this. C++23 introduces explicit lifetime management to solve this.

Always using std::construct_at is also not viable, because it value-initializes the storage, i.e. we can't create a buffer that remains uninitialized until written to.

The solution for implicit-lifetime types only in C++23 looks as follows:

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

Note: implicit-lifetime types are always trivially destructible, which is why we can omit std::destroy_at.

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;
}