Perché è possibile inizializzare una serie regolare da {}, ma non uno std :: array di

Question

Questo funziona:

int arr[10] = {}; 

Tutti gli elementi di arr sono il valore-inizializzato a zero.

Perché non questo lavoro:

std::array<int, 10> arr({}); 

ottengo il seguente avvertimento da g ++ (versione 4.8.2):

avvertimento: inizializzatore per il membro std' mancante :: serie < int, 10ul> :: _ M_elems '

Answer 1

Ci sono due problemi uno che è una questione di stile e l'avviso.

Sebbene possa non essere ovvio, l'inizializzazione di aggregazione avviene su un temporaneo che viene quindi utilizzato come argomento per il costruttore di copie. Il più idiomatico per fare questa inizializzazione sarebbe il seguente:

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

Anche se questo lascia ancora l'avviso.

L'avvertimento è coperto da gcc bug report: - -Wmissing-field-initializers relaxation request e uno dei commenti dice:

[...] Sicuramente, la sintassi C++ di dire MyType x = {}; dovrebbe essere sostenuta, come si vede qui:

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

dove per esempio:

struct S { 
    int a; 
    float b; 
    std::string str; 
}; 

S s = {}; // identical to S s = {0, 0.0, std::string}; 

che non dovrebbe mettere in guardia per i motivi indicati nei commenti precedenti.

e un commento di follow-up dice:

La mia dichiarazione circa zero-inizializzazione è stato impreciso (grazie), ma il punto generale si trova ancora: in C devi scrivere '= {0 } 'dal momento che inizializzatore di parentesi vuote non è supportato dalla lingua (si ottiene un avviso con -pedantic); in C++, puoi scrivere '= {}' o 'T foo = T();', ma non è necessario scrivere '= {0}' in modo specifico.

Le ultime versioni di gcc non producono questo avviso per questo caso, see it live working with gcc 5.1.

Possiamo vedere questo argomento anche nelle liste degli sviluppatori Clang nel numero: -Wmissing-field-initializers.

Per riferimento il progetto standard C++ 11 sezione 8.5.1[dcl.init.aggr] dice:

Se ci sono meno di inizializzazione-clausole della lista che ci sono membri nel complesso, quindi ogni membro non esplicitamente inizializzato va inizializzato da una lista vuota di inizializzazione (8.5.4) . [ Esempio:

struct S { int a; const char* b; int c; }; 
S ss = { 1, "asdf" }; 

inizializza ss.a con 1, ss.b con "asdf", e ss.c con il valore di un'espressione della forma int(), cioè, 0. - fine esempio]

Così come questo è C++ valido, anche se come indicato utilizzando {} non è valido C99. Si potrebbe obiettare che si tratta solo di un avvertimento, ma questo sembra C++ idiomatico usando {} per l'inizializzazione degli aggregati ed è problematico se si utilizza -Werror per trasformare gli avvisi in errori.

Answer 2

primo luogo, è può utilizzare il ({}) inizializzatore con un oggetto std::array, ma semanticamente che sta per inizializzazione diretta usando costruttore di copia da un std::array oggetto valore inizializzato temporaneo, cioè è equivalente a

std::array<int, 10> arr(std::array<int, 10>{}); 

E in realtà dovrebbe compilare.

In secondo luogo, non si ha realmente bisogno di andare il modo ({}) quando si può semplicemente fare

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

o

std::array<int, 10> arr{}; 

Il primo dei due è il più sintatticamente simile al vostro int arr[10] = {}; , il che mi fa chiedere perché non l'abbia provato all'inizio. Perché hai deciso di utilizzare ({}) anziché = {} quando hai creato la versione della sintassi = {}?

Answer 3

numero sufficiente di persone hanno fatto notare come un "problema" quando si compila con -Werror che penso vale la pena ricordare che il problema va via se basta raddoppiare:

std::array<int, 10> arr{{}}; 

non produce alcun avvertimento per me su gcc 4.9.2.

Per aggiungere un po 'al motivo per cui questo lo risolve: ho capito che std :: array è in realtà una classe con un array C come unico membro. Quindi raddoppiare le parentesi ha senso: le parentesi esterne indicano che si sta inizializzando la classe, e quindi le parentesi interne predefinite inizializzano l'unico membro della classe.

Poiché non vi è alcuna ambiguità quando c'è una sola variabile in una classe, usare solo una coppia di {} dovrebbe essere ragionevole, ma gcc è eccessivamente pedante qui, e avverte.