std::ranges:: uninitialized_default_construct_n

Construye objetos de tipo std:: iter_value_t < I > en el área de memoria no inicializada first + [ ​ 0 ​ , count ) mediante inicialización por defecto , como si fuera mediante return ranges:: uninitialized_default_construct ( std:: counted_iterator ( first, count ) ,
std:: default_sentinel ) . base ( ) ;

Si se lanza una excepción durante la inicialización, los objetos ya construidos se destruyen en un orden no especificado.

Las entidades similares a funciones descritas en esta página son algorithm function objects (conocidas informalmente como niebloids ), es decir:

• No se pueden especificar listas de argumentos de plantilla explícitas al llamar a cualquiera de ellos.
• Ninguno de ellos es visible para la búsqueda dependiente de argumento .
• Cuando cualquiera de ellos es encontrado mediante la búsqueda no calificada normal como el nombre a la izquierda del operador de llamada de función, la búsqueda dependiente de argumento queda inhibida.

Parámetros

Valor de retorno

Como se describió anteriormente.

Complejidad

Lineal en count .

Excepciones

Cualquier excepción lanzada durante la construcción de los elementos en el rango de destino.

Notas

Una implementación puede omitir la construcción de objetos (sin cambiar el efecto observable) si no se llama a ningún constructor por defecto no trivial al inicializar por defecto un objeto std:: iter_value_t < I > , lo cual puede detectarse mediante std::is_trivially_default_constructible .

Notas

Implementación posible

struct uninitialized_default_construct_n_fn
{
    template<no-throw-forward-iterator I>
        requires std::default_initializable<std::iter_value_t<I>>
    constexpr I operator()(I first, std::iter_difference_t<I> count) const
    {
        auto iter = std::counted_iterator(first, count);
        return ranges::uninitialized_default_construct(iter, std::default_sentinel).base();
    }
};
inline constexpr uninitialized_default_construct_n_fn uninitialized_default_construct_n{};

Ejemplo

#include <cstring>
#include <iostream>
#include <memory>
#include <string>
int main()
{
    struct S { std::string m{"█▓▒░ █▓▒░ "}; };
    constexpr int n{4};
    alignas(alignof(S)) char out[n * sizeof(S)];
    try
    {
        auto first{reinterpret_cast<S*>(out)};
        auto last = std::ranges::uninitialized_default_construct_n(first, n);
        auto count{1};
        for (auto it{first}; it != last; ++it)
            std::cout << count++ << ' ' << it->m << '\n';
        std::ranges::destroy(first, last);
    }
    catch (...)
    {
        std::cout << "Exception!\n";
    }
    // Para tipos escalares, uninitialized_default_construct_n
    // generalmente no rellena con ceros el área de memoria no inicializada dada.
    constexpr int sample[]{1, 2, 3, 4, 5, 6};
    int v[]{1, 2, 3, 4, 5, 6};
    std::ranges::uninitialized_default_construct_n(std::begin(v), std::size(v));
    if (std::memcmp(v, sample, sizeof(v)) == 0)
    {
        // Comportamiento posiblemente indefinido, pendiente de CWG 1997:
        // for (const int i : v) { std::cout << i << ' '; }
        for (const int i : sample)
            std::cout << i << ' ';
    }
    else
        std::cout << "¡No especificado!";
    std::cout << '\n';
}

1 █▓▒░ █▓▒░
2 █▓▒░ █▓▒░
3 █▓▒░ █▓▒░
4 █▓▒░ █▓▒░
1 2 3 4 5 6

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

Véase también