¿Por qué la inicialización de la matriz de pares todavía necesita llaves dobles en C++14?

La regla de elisión de llaves de C++14 se aplica solo a la inicialización de subagregaciones.

Así que, por ejemplo, algo como esto funciona:

std::array<std::array<int, 3>, 3> a{1, 11, 2, 22, 3, 33};

Aquí se puede inicializar un agregado de agregados sin llaves adicionales.

Pero std::pair no es un agregado (tiene constructores), por lo que la regla no se aplica.

Lo que significa que sin la regla de elisión de llaves, std::array, siendo en sí mismo un agregado con una matriz dentro, necesita un conjunto adicional de llaves para be list-initialized. Recuerde que la plantilla de clase array se implementa como:

template<typename T, std::size_t N> 
struct array {
  T elems[N];
};

Para list-inicializarlo sin la regla de elisión de llaves, necesita un conjunto adicional de llaves para llegar al miembro elems.

Sin las llaves dobles, la declaración es simplemente ambigua. Considere el siguiente código:

    std::array<std::pair<int, int>, 1> a = {{ {1, 2} }};
    std::array<int, 2> b = { {1, 2} };

Sin llaves dobles en la primera definición, el compilador tratará { {1,2} } como una lista de inicialización escalar para array<int, 2>. Necesita declarar una anidada-init-list para que el compilador reconozca que la lista interna también es aggregate-initialized (vs.scalar initialized), de modo que pueda construir un array de std::pair.

En teoría std::array debe inicializarse con inicialización agregada. Así que en realidad esto:

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

Es un azúcar sintáctico para esto:

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

Como puede ver, en el primero parece que inicializo array con valores, pero en realidad es inicialización agregada con lista de inicio entre corchetes. Esto es claro como un día en la segunda situación. Así que eso es para empezar.

Ok Entonces, ¿por qué no funciona esto?

std::array<std::pair<int, int>, 3> b {{1, 11}, {2, 22}, {3, 33}};

Bueno, en pocas palabras - el compilador no puede distinguir qué tipo de sintaxis Está utilizando para inicializar la matriz. {1, 11} se puede interpretar tanto como lista inicializadora y usar la primera versión o se puede interpretar como un par e ir con la segunda versión.

Este código:

std::array<std::pair<int, int>, 3> b {{{1, 11}, {2, 22}, {3, 33}}};.

Elimina la ambigüedad.

Fuente: http://en.cppreference.com/w/cpp/language/aggregate_initialization

Voy a adivinar aquí.
La lista inicializadora para std::array<T,n> debe ser una lista de T (o trivialmente construible para T). Así que usted podría hacer

std::array<std::pair<int,int>,3> b { std::pair{1,11}, std::pair{2,22}, std::pair{3,33} };

Pero eso es tediosamente prolijo. Para obtener la conversión a std::pair<int,int> que desea, debe proporcionar una lista de inicializadores, por lo que

std::array<std::pair<int,int>,3> b {
    { // element 1
      { // initialize from:
        { 1,11 } // std::initializer_list
       }
     },
  ...
};

No puedo defender esto más, pero note que std::vector<T, Allocator>::vector( std::initializer_list<T>, const Allocator& alloc=Allocator()) está definido pero std::array<T,n>::array( std::initializer_list<T> ) no lo está. Tampoco se define std::pair<U,T>::pair( std::initializer_list<??> ).