std::construct_at

template< class T, class... Args >
constexpr T* construct_at( T* location, Args&&... args );

Erzeugt ein T-Objekt, das mit den Argumenten in args an der angegebenen Adresse location initialisiert wird.

Äquivalent zu
if constexpr (std::is_array_v<T>)
    return ::new (voidify (*location)) T[1]();
else
    return ::new (voidify (*location)) T(std::forward<Args>(args)...); , außer dass construct_at in der Auswertung von konstanten Ausdrücken(bis C++26) verwendet werden kann.

Wenn construct_at in der Auswertung eines konstanten Ausdrucks expr aufgerufen wird, muss location entweder auf einen durch std::allocator<T>::allocate erhaltenen Speicher oder auf ein Objekt zeigen, dessen Lebensdauer innerhalb der Auswertung von expr begonnen hat.

Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn alle folgenden Bedingungen erfüllt sind:

• std::is_unbounded_array_v<T> ist false.
• ::new(std::declval<void*>()) T(std::declval<Args>()...) ist wohlgeformt, wenn es als nicht ausgewerteter Operand behandelt wird.

Wenn std::is_array_v<T> true ist und sizeof...(Args) nicht Null ist, ist das Programm fehlerhaft.

Parameter

Rückgabewert

location

Beispiel

#include <bit>
#include <memory>
class S
{
    int x_;
    float y_;
    double z_;
public:
    constexpr S(int x, float y, double z) : x_{x}, y_{y}, z_{z} {}
    [[nodiscard("no side-effects!")]]
    constexpr bool operator==(const S&) const noexcept = default;
};
consteval bool test()
{
    alignas(S) unsigned char storage[sizeof(S)]{};
    S uninitialized = std::bit_cast<S>(storage);
    std::destroy_at(&uninitialized);
    S* ptr = std::construct_at(std::addressof(uninitialized), 42, 2.71f, 3.14);
    const bool res{*ptr == S{42, 2.71f, 3.14}};
    std::destroy_at(ptr);
    return res;
}
static_assert(test());
int main() {}

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

Siehe auch