std::ranges::construct_at

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

Erstellt ein T-Objekt, das mit den Argumenten in args an der gegebenen 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.

Die auf dieser Seite beschriebenen funktionsartigen Entitäten sind Algorithmus-Funktionsobjekte (informell als Niebloids bekannt), das heißt:

• Explizite Vorlagenargumentlisten können beim Aufruf keiner von ihnen angegeben werden.
• Keine von ihnen sind für argumentabhängige Namenssuche sichtbar.
• Wenn eine von ihnen durch normale unqualifizierte Namenssuche als Name links vom Funktionsaufrufoperator gefunden wird, wird argumentabhängige Namenssuche unterdrückt.

Parameter

Rückgabewert

location

Hinweise

std::ranges::construct_at verhält sich genauso wie std::construct_at , mit der Ausnahme, dass es für argumentabhängige Suche unsichtbar ist.

Beispiel

#include <iostream>
#include <memory>
struct S
{
    int x;
    float y;
    double z;
    S(int x, float y, double z) : x{x}, y{y}, z{z} { std::cout << "S::S();\n"; }
    ~S() { std::cout << "S::~S();\n"; }
    void print() const
    {
        std::cout << "S { x=" << x << "; y=" << y << "; z=" << z << "; };\n";
    }
};
int main()
{
    alignas(S) unsigned char buf[sizeof(S)];
    S* ptr = std::ranges::construct_at(reinterpret_cast<S*>(buf), 42, 2.71828f, 3.1415);
    ptr->print();
    std::ranges::destroy_at(ptr);
}

S::S();
S { x=42; y=2.71828; z=3.1415; };
S::~S();

Fehlerberichte

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

Siehe auch