c++ - nombres - Cómo crear std:: array con la lista de inicialización sin proporcionar el tamaño directamente

llenar un arreglo char

Question

Esta pregunta ya tiene una respuesta aquí:

• ¿Cómo emular el comportamiento de la inicialización de la matriz C "int arr [] = {e1, e2, e3, ...}" con std :: array? 9 respuestas

¿Cómo puedo hacer compilación a3 ?

int main()
{
    int a1[] = { 1, 2, 3 };
    std::array<int, 3> a2 = { 1, 2, 3 };
    std::array<int> a3 = { 1, 2, 3 };
}

Es muy incómodo y quebradizo codificar el tamaño de la matriz cuando se usa una lista de inicialización, especialmente las largas. ¿Hay algún trabajo alrededor? Espero que de otra manera me decepcione porque odio las matrices C y std::array se supone que son su reemplazo.

Answer 1

Actualmente no hay manera de hacer esto sin rodar su propia make_array , hay una propuesta para este N3824: make_array que tiene el siguiente alcance:

LWG 851 ​​destinado a proporcionar una sintaxis de reemplazo para

array<T, N> a = { E1, E2, ... };

, asi que lo siguiente

auto a = make_array(42u, 3.14);

está bien formado (con static_casts adicionales aplicados dentro) porque

array<double, 2> = { 42u, 3.14 };

esta bien formado

Este documento pretende proporcionar un conjunto de interfaces de creación de matriz std :: que son integrales tanto desde el punto de vista de la tupla como desde el punto de vista de la matriz, por lo que el estrechamiento está naturalmente prohibido. Ver más detalles guiados por esta dirección en Decisiones de Diseño.

También incluye una implementación de muestra , que es bastante larga, por lo que copiar aquí no es práctico, pero Konrad Rudolph tiene una versión simplificada here que es consistente con la implementación de muestra anterior:

template <typename... T>
constexpr auto make_array(T&&... values) ->
    std::array<
       typename std::decay<
           typename std::common_type<T...>::type>::type,
       sizeof...(T)> {
    return std::array<
        typename std::decay<
            typename std::common_type<T...>::type>::type,
        sizeof...(T)>{std::forward<T>(values)...};
}

Answer 2

Estás siendo un poco demasiado dramático cuando dices "se requiere una función tan horriblemente compleja (para mí)". Usted puede hacer una versión simplificada, la propuesta también incluye una función "to_array" para convertir matrices C y deducir el tipo del primer parámetro. Si dejas eso se vuelve bastante manejable.

template<typename T, typename... N>
auto my_make_array(N&&... args) -> std::array<T,sizeof...(args)>
{
    return {std::forward<N>(args)...};
}

que luego puedes llamar como

auto arr = my_make_array<int>(1,2,3,4,5);

Edición: Debo mencionar que en realidad hay una versión de eso en la propuesta que pasé por alto, así que esto debería ser más correcto que mi versión:

template <typename V, typename... T>
constexpr auto array_of(T&&... t)
    -> std::array < V, sizeof...(T) >
{
    return {{ std::forward<T>(t)... }};
}