Confusão sobre omitir os aparelhos externos nas listas inicializadoras para agregados e estruturas de pod

No reino da programação C, surge uma pergunta comum sobre o uso de faixas nos listões iniciais. Especificamente, os programadores podem encontrar cenários em que os aparelhos externos parecem ser necessários para certos tipos de agregados, mas não para outros. Este artigo visa aprofundar -se mais do tópico e fornecer esclarecimentos sobre quando os aparelhos externos podem ser omitidos. { int foo; barra dupla; }; std :: Array a1 = // Erro C2078: Muitos inicializadores { {0, 0.1}, {2, 3.4} }; // OK Std :: Array A2 = {0.1, 2.3};

O erro indica que existem muitos inicializadores para A1, sugerindo que os aparelhos extras são necessários. No entanto, omitir os aparelhos externos para A2 não resulta em um erro. Essa discrepância levanta a questão de por que os aparelhos externos são necessários para A1, mas não para A2. A matriz STD :: é classificada como um tipo agregado e um tipo de dados antigo simples (POD), enquanto outros contêineres da biblioteca padrão não são. Ao contrário dos contêineres com construtores definidos pelo usuário, o Std :: Array não possui um. Seu primeiro membro de dados é uma matriz de tamanho n, especificada como um argumento de modelo. Este membro de dados é inicializado diretamente usando uma lista de inicializadores. Os aparelhos adicionais são necessários porque incluem a matriz interna que está sendo inicializada. estruturar aarray { Um dados [2]; // Uma matriz interna }; inicializando essa estrutura requer o uso de aparelhos para denotar o início e o fim da matriz interna sendo inicializada:

aarray A1 = { {// começa a inicialização da matriz interna {// inicializa o primeiro elemento da matriz interna 0, 0.1 }, // termina a inicialização do primeiro elemento {2, 3.4} // inicializa o segundo elemento da matriz interna } // termina a inicialização da matriz interna }; // Erro: muitos inicializadores se não estiver usando aparelhos Aarray b1 = { 0, 0.1, 2, 3.4 };

struct A
{
    int foo;
    double bar;
};

std::array a1 = 
  // error C2078: too many initializers
  {
    {0, 0.1},
    {2, 3.4}
  };

// OK
std::array a2 = {0.1, 2.3};

No caso de Std :: Array , a situação é diferente porque o dobro não é um tipo agregado. Em vez disso, Std :: Array é considerado um agregado de primitivas. The following code is valid without outer braces because the primitive values ​​are directly initialized within the aggregate:std::array a2 = {0.1, 2.3};

// Custom aggregate with no user-defined constructor
struct Aarray
{
   A data[2];  // An internal array
};