Namespaces
Variants

    std::construct_at

    From cppreference.com
     
    C++
     
    Algorithm library
    Constrained algorithms and algorithms on ranges (C++20)
    Constrained algorithms, e.g. ranges::copy, ranges::sort, ...
    Non-modifying sequence operations    
    Batch operations
    (C++17)
    Search operations
    Modifying sequence operations
    Copy operations
    (C++11)
    (C++11)
    (C++11)
    Swap operations
    Transformation operations
    Generation operations
    Removing operations
    Order-changing operations
    (until C++17)(C++11)
    (C++20)(C++20)
    Sampling operations
    (C++17)

    Sorting and related operations
    Partitioning operations
    (C++11)    
    (C++11)

    Sorting operations
    Binary search operations
    (on partitioned ranges)
    Set operations (on sorted ranges)
    Merge operations (on sorted ranges)
    Heap operations
    Minimum/maximum operations
    (C++11)
    (C++17)
    Lexicographical comparison operations
    (C++20)
    Permutation operations


     
    Specialized <memory> algorithms
    Helper templates (exposition only*)
    (C++17)
    Object (batch) construction
    Object (batch) destruction
    (C++17)
    (C++17)
    (C++17)
     
    Defined in header <memory> 
    template< class T, class... Args >
constexpr T* construct_at( T* location, Args&&... args );
    		(since C++20)
    See More

    Creates a T object initialized with the arguments in args at given address location.

    Equivalent to
    if constexpr (std::is_array_v<T>)
        return ::new (voidify (*location)) T[1]();
    else
        return ::new (voidify (*location)) T(std::forward<Args>(args)...);     , except that construct_at may be used in evaluation of constant expressions(until C++26).

    When construct_at is called in the evaluation of some constant expression expr, location must point to either a storage obtained by std::allocator<T>::allocate or an object whose lifetime began within the evaluation of expr.

    This overload participates in overload resolution only if all following conditions are satisfied:

    • std::is_unbounded_array_v<T> is false.
    • ::new(std::declval<void*>()) T(std::declval<Args>()...) is well-formed when treated as an unevaluated operand.

    If std::is_array_v<T> is true and sizeof...(Args) is nonzero, the program is ill-formed.

    Parameters

    location - pointer to the uninitialized storage on which a T object will be constructed
    args... - arguments used for initialization

    Return value

    location

    Example

    Run this code
    #include <memory>

struct S
{
    int x;
    float y;
    double z;

    constexpr bool friend operator==(S, S) noexcept = default;
};

consteval bool test()
{
    std::allocator<S> allocator;
    S* uninitialized = allocator.allocate(1);

    S* ptr = std::construct_at(uninitialized, 42, 2.71f, 3.14);
    const bool res = *ptr == S{42, 2.71f, 3.14};

    std::destroy_at(ptr);
    allocator.deallocate(uninitialized, 1);
    return res;
}
static_assert(test());

int main() {}

    Defect reports

    The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

    DR Applied to Behavior as published Correct behavior
    LWG 3436 C++20 construct_at could not create objects of array types can value-initialize bounded arrays

    See also

    		 allocates uninitialized storage
    (public member function of std::allocator<T>) [edit]
    [static]
    		 constructs an object in the allocated storage
    (function template) [edit]
    (C++17)
    		 destroys an object at a given address
    (function template & algorithm function object)[edit]
    (C++20)
    (C++20)
    		 creates an object at a given address
    (algorithm function object)[edit]