c++ - Inicializando un std:: array con un valor constante

initialization stdarray

Question

Necesito inicializar todos los elementos de una std::array con un valor constante, como se puede hacer con std::vector .

#include <vector>
#include <array>

int main()
{
  std::vector<int> v(10, 7);    // OK
  std::array<int, 10> a(7);     // does not compile, pretty frustrating
}

¿Hay alguna manera de hacer esto con elegancia?

En este momento estoy usando esto:

std::array<int, 10> a;
for (auto & v : a)
  v = 7;

pero me gustaría evitar usar código explícito para la inicialización.

Answer 1

Con std::index_sequence , puede hacer:

namespace detail
{
    template <typename T, std::size_t ... Is>
    constexpr std::array<T, sizeof...(Is)>
    create_array(T value, std::index_sequence<Is...>)
    {
        // cast Is to void to remove the warning: unused value
        return {{(static_cast<void>(Is), value)...}};
    }
}

template <std::size_t N, typename T>
constexpr std::array<T, N> create_array(const T& value)
{
    return detail::create_array(value, std::make_index_sequence<N>());
}

Con el uso

auto a = create_array<10 /*, int*/>(7); // auto is std::array<int, 10>

Que, a diferencia de la solución std::fill , maneja el tipo constructivo no predeterminado.

Answer 2

Desde C ++ 17 puede escribir una función constexpr para configurar eficientemente la matriz, ya que los elementos de acceso son constexpr ahora. Este método también funcionará para varios otros esquemas de configuración de valores iniciales:

#include <array>

template<typename T, size_t N>
constexpr auto make_array(T value) -> std::array<T, N>
{
    std::array<T, N> a{};
    for (auto& x : a)
        x = value;
    return a;
}

int main()
{
    auto arr = make_array<int, 10>(7);
}

Answer 3

El tipo std::array es un agregado que admite la inicialización de la lista:

std::array<int, 10> a{2, 2, 2, 2, 2, 2, 2, 2, 2, 2};

También es compatible con la inicialización agregada:

std::array<int, 10> a = {2, 2, 2, 2, 2, 2, 2, 2, 2, 2};

Esto es inconveniente y propenso a errores para matrices largas, y sería mejor usar una solución como Jarod42 para esos.

Answer 4

Por desgracia no; std::array admite la inicialización agregada, pero eso no es suficiente aquí.

Afortunadamente, puede usar std::fill , o incluso std::array<T,N>::fill , que, desde C ++ 20, es elegante ya que este último se convierte en constexpr .

Referencia: https://en.cppreference.com/w/cpp/container/array/fill

Answer 5

Puedes hacer lo siguiente

std::array<int, 10> a; 
a.fill(2/*or any other value*/);

O use std::fill del archivo de encabezado de algoritmos. Para incluir el uso del archivo de encabezado de algoritmos

#include <algorithm>