std::uninitialized_default_construct_n

Since C++17

Header: <memory>

Constructs objects of type typename std::iterator_traits::value_type in the uninitialized memory area first+[0,count) by default-initialization, as if by for (; count > 0; (void)++first, –count) ::new (voidify(*first)) typename std::iterator_traits::value_type; return first;

# Declarations

template< class NoThrowForwardIt, class Size >
NoThrowForwardIt uninitialized_default_construct_n
( NoThrowForwardIt first, Size count );

(since C++17) (constexpr since C++26)

template< class ExecutionPolicy, class NoThrowForwardIt, class Size >
NoThrowForwardIt uninitialized_default_construct_n
( ExecutionPolicy&& policy, NoThrowForwardIt first, Size count );

(since C++17)

# Parameters

first: the beginning of the range of elements to initialize
count: the number of elements to construct
policy: the execution policy to use

# Return value

As described above.

# Notes

Feature-test macro Value Std Feature __cpp_lib_raw_memory_algorithms 202411L (C++26) constexpr for specialized memory algorithms, (1)

# Example

#include <cstring>
#include <iostream>
#include <memory>
#include <string>
 
struct S
{
    std::string m{"default value"};
};
 
int main()
{
    constexpr int n{3};
    alignas(alignof(S)) unsigned char mem[n * sizeof(S)];
 
    try
    {
        auto first{reinterpret_cast<S*>(mem)};
        auto last = std::uninitialized_default_construct_n(first, n);
 
        for (auto it{first}; it != last; ++it)
            std::cout << it->m << '\n';
 
        std::destroy(first, last);
    }
    catch(...)
    {
        std::cout << "Exception!\n";
    }
 
    // For scalar types, uninitialized_default_construct_n
    // generally does not zero-initialize the given uninitialized memory area.
    int v[]{1, 2, 3, 4};
    const int original[]{1, 2, 3, 4};
    std::uninitialized_default_construct_n(std::begin(v), std::size(v));
 
    // An attempt to access v might be an undefined behavior,
    // pending CWG 1997 to be resolved:
    // for (const int i : v)
    //     std::cout << i << ' ';
 
    // The result is unspecified:
    std::cout << (std::memcmp(v, original, sizeof(v)) == 0 ? "un" : "") << "modified\n";
}

# Defect reports

DR	Applied to	Behavior as published	Correct behavior
LWG 3870	C++20	this algorithm might create objects on a const storage	kept disallowed