std::ranges::uninitialized_fill - cppreference.com

1) Construye N copias del valor dado x en un área de memoria no inicializada, designada por el rango [first, last), donde N es ranges::distance(first, last).

for (; first != last; ++first) {
    ::new (
        const_cast<void*>(static_cast<const volatile void*>(std::addressof(*first)))
        ) std::remove_reference_t<std::iter_reference_t<I>>(x);
}
return first;

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

2) Igual que (1), pero usa r como rango, como si se usara ranges::begin(r) como first, y ranges::end(r) como last.

Las entidades similares a funciones descritas en esta página son niebloids, es decir:

• Las listas de argumentos de plantilla explícitas no se pueden especificar al llamar a cualquiera de ellas.
• Ninguna de ellas es visible para la búsqueda dependiente de argumentos.
• Cuando alguna de ellas se encuentra mediante la búsqueda normal no calificada como el nombre a la izquierda del operador de llamada a función, se inhibe la búsqueda dependiente de argumentos.

En la práctica, pueden implementarse como objetos función o con extensiones de compilador especiales.

Parámetros

Valor de retorno

Un iterador igual a last.

Complejidad

𝓞(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 ranges::uninitialized_fill, p. ej., mediante el uso de ranges::fill, si el tipo valor del rango de salida es TrivialType.

Posible implementación

struct uninitialized_fill_fn {
    template <no-throw-forward-iterator I, no-throw-sentinel-for<I> S, class T>
    requires std::constructible_from<std::iter_value_t<I>, const T&>
    I operator()( I first, S last, const T& x ) const {
        I rollback {first};
        try {
            for (; !(first == last); ++first)
                ranges::construct_at(std::addressof(*first), x);
            return first;
        } catch (...) { // rollback: destruir los elementos construidos
            for (; rollback != first; ++rollback)
                ranges::destroy_at(std::addressof(*rollback));
            throw;
        }
    }

    template <no-throw-forward-range R, class T>
    requires std::constructible_from<ranges::range_value_t<R>, const T&>
    ranges::borrowed_iterator_t<R>
    operator()( R&& r, const T& x ) const {
        return (*this)(ranges::begin(r), ranges::end(r), x);
    }
};

inline constexpr uninitialized_fill_fn uninitialized_fill{};

Ejemplo

#include <iostream>
#include <memory>
#include <string>

int main()
{
    constexpr int n {4};
    alignas(alignof(std::string)) char out[n * sizeof(std::string)];

    try
    {
        auto first {reinterpret_cast<std::string*>(out)};
        auto last {first + n};
        std::ranges::uninitialized_fill(first, last, "▄▀▄▀▄▀▄▀");

        int count {1};
        for (auto it {first}; it != last; ++it) {
            std::cout << count++ << ' ' << *it << '\n';
        }

        std::ranges::destroy(first, last);
    }
    catch(...)
    {
        std::cout << "Exception!\n";
    }
}

1 ▄▀▄▀▄▀▄▀
2 ▄▀▄▀▄▀▄▀
3 ▄▀▄▀▄▀▄▀
4 ▄▀▄▀▄▀▄▀

Véase también