std::ranges::construct_at

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

Crée un T objet initialisé avec les arguments de args à l'adresse donnée location.

Équivalent à if constexpr (std::is_array_v<T>)
    return ::new (voidify (*location)) T[1]();
else
    return ::new (voidify (*location)) T(std::forward<Args>(args)...); , sauf que construct_at peut être utilisé dans l'évaluation d'expressions constantes(jusqu'à C++26).

Lorsque construct_at est appelé dans l'évaluation d'une expression constante expr, location doit pointer soit vers un stockage obtenu par std::allocator<T>::allocate soit vers un objet dont la durée de vie a commencé dans l'évaluation de expr.

Cette surcharge participe à la résolution de surcharge seulement si toutes les conditions suivantes sont satisfaites :

• std::is_unbounded_array_v<T> est false.
• ::new(std::declval<void*>()) T(std::declval<Args>()...) est bien formé lorsqu'il est traité comme un opérande non évalué.

Si std::is_array_v<T> est true et que sizeof...(Args) est non nul, le programme est mal formé.

Les entités de type fonction décrites sur cette page sont des objets fonctions algorithmes (informellement appelés niebloids), c'est-à-dire :

• Les listes d'arguments de modèle explicites ne peuvent pas être spécifiées lors de leur appel.
• Aucun d'entre eux n'est visible par recherche dépendante des arguments.
• Lorsque l'un d'entre eux est trouvé par recherche non qualifiée normale comme le nom à gauche de l'opérateur d'appel de fonction, recherche dépendante des arguments est inhibée.

Paramètres

Valeur de retour

location

Notes

std::ranges::construct_at se comporte exactement de la même manière que std::construct_at , sauf qu'il est invisible à la recherche dépendante des arguments.

Exemple

#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();

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

Voir aussi