Call constructor on uninitialized memory in C++

Question

I have some legacy C++ (10+ years old) that I am trying to compile where there is a buffer/allocator, that is used to get some memory for a new object. Then a function, std::_Construct, is called that I assume is used to call the constructor for the object (since the allocator only returns a void*). But I suspect that it is only a feature of an older version of Visual Studio (I can't find anything from before VS2015), so I am wondering: How can I call the constructor on a piece of uninitialized memory that I have casted to the class I'm trying to construct?

Here is a little pseudo-code of what I'm trying to achieve:

BufferManagementClass mBuffMan; // "allocator"

class A { ... };

A* initObject() {
    A* pA = static_cast<A*>(mBuffMan.GetBuffer(sizeof(A))); // GetBuffer returns void*, so I cast it.
    if (pA == NULL)
        return NULL;

    /*
    How do I call the constructor of the memory pA points to here?
    I assume that is needed before I can call any methods in pA?
    */

    pA->someFunc();
    pA->someOtherFunc();
    return pA;
}

I have converted the project to C++14 (since that's the earliest standard version that VS2019 supports) by the way.

Do you want [placement new](https://en.cppreference.com/w/cpp/language/new#Placement_new)? — ChrisMM, Apr 20 '22 at 14:34
placement new is what you want when you want to construct an object at a particular memory address — NathanOliver, Apr 20 '22 at 14:35
The `_C` at the beginning of that name means that it is a name that's reserved for use by the implementation. It's an internal detail of the standard library implementation, and should not be used in your code. — Pete Becker, Apr 20 '22 at 14:51
Thanks everyone! I Hadn't heard about placement new before. I'll post this as an answer to my question — NollerNiller, Apr 20 '22 at 14:51

eerorika · Accepted Answer · 2022-04-20T15:08:52.257

There is no std::_Construct in standard library. The underscore + upper case prefix implies that this is a language extension or implementation detail of the standard library. Since it has disappeared in version change, it was probably the latter.

The standard way to create an object in uninitalised storage that has been available for 24+ years is to use placement-new syntax:

void* memory = mBuffMan.GetBuffer(sizeof(A))
A* aP = new(memory) A(/*constructor arguments*/);

Since C++11, an alternative is to std::allocator_traits::construct. This has the advantage of having become constexpr since C++20. This approach is conventional when you use an allocator, which is quite typical when the allocation and object creation is separated:

using ExampleAlloc = std::allocator<A>;
using AT = std::allocator_traits<ExampleAlloc>;
ExampleAlloc alloc{};
A* aP = AT.allocate(alloc, 1);
AT.construct(alloc, memory, /*constructor arguments*/);

Same was possible pre C++11 using std::allocator::construct, but that has been deprecated in C++17 in favour of using std::allocator_traits and removed in C++20.

Another alternative, when you are dealing with creation of multiple object into the memory, is to use std::uninitialized_copy, std::uninitialized_fill, std::uninitialized_move (C++17), std::uninitialized_default_construct (C++17), std::uninitialized_value_construct (C++17):

extern A value;
A* aP = AT.allocate(alloc, count);
std::uninitialized_fill_n(aP, count, value);

Lastly, C++20 added yet another alternative, std::construct_at.

score 0 · Answer 2 · answered Apr 20 '22 at 14:54

0

The C++20 solution is std::construct_at. But you can use the traditional placement new too.

answered Apr 20 '22 at 14:54

Red.Wave

2,790
11
17

Call constructor on uninitialized memory in C++

2 Answers2