Perché std :: array <int, 10> x non è inizializzato a zero ma std :: array <int, 10> x = std :: array <int, 10>() sembra essere?

Question

Ho appena fatto due domande sull'inizializzazione di array e valore here e here. Ma con questo codice, mi sono perso:

#include <iostream> 
#include <iomanip> 
#include <array> 

template <class T, class U = decltype(std::declval<T>().at(0))> 
inline U f1(const unsigned int i) 
{T x; return x.at(i);} 

template <class T, class U = decltype(std::declval<T>().at(0))> 
inline U f2(const unsigned int i) 
{T x = T(); return x.at(i);} 

int main() 
{ 
    static const unsigned int n = 10; 
    static const unsigned int w = 20; 
    for (unsigned int i = 0; i < n; ++i) { 
     std::cout<<std::setw(w)<<i; 
     std::cout<<std::setw(w)<<f1<std::array<int, n>>(i); 
     std::cout<<std::setw(w)<<f2<std::array<int, n>>(i); 
     std::cout<<std::setw(w)<<std::endl; 
    } 
    return 0; 
} 

Come previsto, f1 restituiscono valori arbitrari come i suoi valori non sono-inizializzato a zero. Ma f2 sembra restituire esclusivamente valori zero:

    0     0     0 
        1     61     0 
        2     0     0 
        3     0     0 
        4   297887440     0 
        5    32767     0 
        6    4196848     0 
        7     0     0 
        8   297887664     0 
        9    32767     0 

Personalmente ho pensato che f2 creerà un array con valori arbitrari e copia/spostarlo x. Ma non sembra essere il caso.

Così, ho due domande:

• Perché?
• Do C++ 11 std::array<T, N> e C-style T[N] hanno lo stesso comportamento in una situazione del genere?

Answer 1

Uso {} o () come inizializzatore, con o senza =, provoca l'inizializzazione valore. Per un tipo con un costruttore implicitamente dichiarato, l'inizializzazione del valore implementa l'inizializzazione zero, che come suggerisce il nome imposta ogni elemento primitivo su 0. Ciò si verifica prima che il costruttore possa essere eseguito, ma in questo caso il costruttore non fa nulla.

Poiché il costruttore non fa nulla (è banale), è possibile vedere i dati non inizializzati.

Per quanto riguarda gli array in stile C, il comportamento è simile se si utilizza = {} anziché = T(), poiché quest'ultimo è illegale. T() richiederebbe un oggetto array temporaneo da assegnare all'oggetto denominato, ma non è possibile assegnare gli array. = {} d'altra parte assegna un array-inizializzatore-elenco alla matrice, e una lista di inizializzazione rinforzata è un costrutto sintattico speciale che non è né un'espressione né un oggetto.