Ver el código de «cpp/memory/ranges/uninitialized value construct n»

← cpp/memory/ranges/uninitialized value construct n

No tienes permiso para modificar esta página, por el siguiente motivo:

La acción que has solicitado está restringida a los usuarios de uno de estos 2 grupos: Usuarios, Administradores.

Puedes ver y copiar el código fuente de esta página.

{{cpp/ranges/title|uninitialized_value_construct_n}}
{{cpp/memory/navbar}}
{{dcl begin}}
{{dcl header | memory}}
{{dcl h | Signatura de la llamada}}
{{dcl | since=c++20 |1=
template <no-throw-forward-iterator I>
requires std::default_initializable<std::iter_value_t<I>>
I uninitialized_value_construct_n( I first, std::iter_difference_t<I> n );
}}
{{dcl end}}

Construye {{tt|n}} objetos de tipo {{c|std::iter_value_t<I>}} en el área de memoria no inicializada que comienza en {{tt|first}} mediante la [[cpp/language/value_initialization|inicialización por valor]], como si fuera por
{{source|1=
for (; n-- > 0; ++first)
  ::new (const_cast<void*>(static_cast<const volatile void*>(std::addressof(*first))))
      std::remove_reference_t<std::iter_reference_t<I>>();
}}

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

{{cpp/ranges/niebloid}}

===Parámetros===
{{par begin}}
{{par | first | El comienzo del rango de elementos a inicializar. }}
{{par | n | El número de elementos a construir. }}
{{par end}}

===Valor de retorno===
El fin del rango de objetos (es decir, {{c|ranges::next(first, n)}}).

===Complejidad===
Lineal en {{c|n}}.

===Excepciones===
La excepción lanzada en la construcción de los elementos en el rango de destino, si existe.

===Notas===
Una implementación puede mejorar la eficiencia de {{tt|ranges::uninitialized_value_construct_n}}, p.ej., mediante el uso de {{lc|ranges::fill_n}}, si el tipo valor del rango es {{named req|TrivialType}} y {{named req|CopyAssignable}}.

===Posible implementación===
{{eq fun | 1=
struct uninitialized_value_construct_n_fn {
    template <no-throw-forward-iterator I>
    requires std::default_initializable<std::iter_value_t<I>>
    I operator()( I first, std::iter_difference_t<I> n ) const {
        using T = std::remove_reference_t<std::iter_reference_t<I>>;
        if constexpr (std::is_trivial_v<T> && std::is_copy_assignable_v<T>)
            return ranges::fill_n(first, n, T());
        I rollback {first};
        try {
            for (; n-- > 0; ++first)
                ::new (const_cast<void*>(static_cast<const volatile void*>
                        (std::addressof(*first)))) T();
            return first;
        } catch (...) { // rollback: destruir los elementos construidos
            for (; rollback != first; ++rollback)
                ranges::destroy_at(std::addressof(*rollback));
            throw;
        }
    }
};

inline constexpr uninitialized_value_construct_n_fn uninitialized_value_construct_n{};
}}

===Ejemplo===
{{example|code=
#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_value_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 << "¡Excepción!\n";
    }

    // Observa que para "tipos triviales" uninitialized_value_construct_n
    // llena con ceros el área de memoria no inicializada dada.
    int v[] { 1, 2, 3, 4, 5, 6, 7, 8 };
    std::cout << ' ';
    for (const int i : v) { std::cout << i << ' '; }
    std::cout << "\n ";
    std::ranges::uninitialized_value_construct_n(std::begin(v), std::size(v));
    for (const int i : v) { std::cout << i << ' '; }
    std::cout << '\n';
}
| output=
1 █▓▒░ █▓▒░ █▓▒░ 
2 █▓▒░ █▓▒░ █▓▒░ 
3 █▓▒░ █▓▒░ █▓▒░ 
4 █▓▒░ █▓▒░ █▓▒░
1 2 3 4 5 6 7 8
0 0 0 0 0 0 0 0
}}

===Véase también===
{{dsc begin}}
{{dsc inc | cpp/memory/ranges/dsc uninitialized_value_construct}}
{{dsc inc | cpp/memory/ranges/dsc uninitialized_default_construct}}
{{dsc inc | cpp/memory/ranges/dsc uninitialized_default_construct_n}}
{{dsc inc | cpp/memory/dsc uninitialized_value_construct_n}}
{{dsc end}}

{{langlinks|de|en|fr|it|ja|pt|ru|zh}}

Plantillas usadas en esta página:

cppreference.com

Buscar

Espacios de nombres

Variantes

Vistas

Acciones

Ver el código de «cpp/memory/ranges/uninitialized value construct n»