Quando i tipi di POD C++ vengono inizializzati a zero?

Question

Provenendo da uno sfondo C, ho sempre pensato che i tipi di POD (ad esempio ints) non fossero mai automaticamente inizializzati a zero in C++, ma sembra che fosse semplicemente sbagliato!

La mia comprensione è che solo i valori POD non statici "nudi" non vengono riempiti a zero, come mostrato nel frammento di codice. Ho capito bene e ci sono altri casi importanti che ho perso?

static int a; 

struct Foo { int a;}; 

void test() 
{ 
    int b;  
    Foo f; 
    int *c = new(int); 
    std::vector<int> d(1); 

    // At this point... 
    // a is zero 
    // f.a is zero 
    // *c is zero 
    // d[0] is zero 
    // ... BUT ... b is undefined  
} 

Answer 1

Supponendo che non hai modificato a prima di chiamare test(), a ha un valore pari a zero, poiché gli oggetti con durata di archiviazione statica vengono inizializzati a zero all'avvio del programma.

d[0] ha un valore pari a zero, poiché il costruttore richiamato da std::vector<int> d(1) ha un secondo parametro che accetta un argomento predefinito; quel secondo argomento è copiato in tutti gli elementi del vettore che si sta costruendo. L'argomento di default è T(), in modo che il codice è equivalente a:

std::vector<int> d(1, int()); 

Lei ha ragione che b ha un valore indeterminato.

f.a e *c hanno entrambi valori indeterminati. Per valutarli inizializzazione (che per i tipi POD è la stessa di inizializzazione zero), è possibile utilizzare:

Foo f = Foo();  // You could also use Foo f((Foo())) 
int* c = new int(); // Note the parentheses 

Answer 2

In realtà alcuni dei valori che sono pari a zero può essere dovuto a voi provare questo codice nella versione di debug dell'applicazione (se questo è il caso).

Se non mi sbaglio, nel codice:

• una dovrebbe essere inizializzato.
• b dovrebbe essere inizializzata
• c dovrebbero puntare a un nuovo (non inizializzato) int
• d dovrebbe essere inizializzato a [0] (come avete indovinato correttamente)

Answer 3

Per me, i tipi POD vengono inizializzati a seconda della parte della memoria sono collocati. Il tuo static int a è allocato sul segmento dati, quindi ha un valore predefinito all'avvio. Tuttavia, penso che f non sia inizializzato nel tuo esempio ...

Answer 4

Non lo fanno. Le versioni di debug bits potrebbero fare ciò, ma in genere è appena messo in memoria e inizializzato su qualunque cosa sia successo come valore in memoria.

Answer 5

Si noti che l'inizializzazione zero eseguita dal sistema operativo come funzionalità di sicurezza viene in genere eseguita solo alla prima allocazione della memoria. Con ciò intendo qualsiasi segmento nelle sezioni heap, stack e dati. Le sezioni stack e dati sono in genere di dimensioni fisse e vengono inizializzate quando l'applicazione viene caricata in memoria.

Il segmento di dati (che contiene dati/codice statici/globali) non viene in genere "riutilizzato", sebbene ciò potrebbe non essere il caso se si carica dinamicamente il codice in fase di runtime.

La memoria nel segmento di stack viene riutilizzata continuamente. Variabili locali, frame di stack di funzioni, ecc. Vengono costantemente utilizzati e riutilizzati e non vengono inizializzati ogni volta, proprio quando l'applicazione viene caricata per la prima volta.

Tuttavia, quando l'applicazione effettua richieste di memoria heap, il gestore di memoria tipicamente zero inizializzare segmenti di memoria prima di concedere la richiesta, ma solo per i nuovi segmenti. Se si effettua una richiesta per memoria heap e c'è spazio libero in un segmento già inizializzato, l'inizializzazione non viene eseguita una seconda volta. Pertanto, non vi è alcuna garanzia che se quel particolare segmento di memoria viene riutilizzato dall'applicazione, verrà nuovamente inizializzato a zero.

Quindi, ad esempio, se si assegna un Foo all'heap, assegnare un valore al proprio campo, eliminare l'istanza di Foo e quindi creare un nuovo Foo sull'heap, c'è la possibilità che il nuovo Foo venga assegnato nella stessa esatta locazione di memoria del vecchio Foo, e quindi il suo campo avrà inizialmente lo stesso valore del campo del vecchio Foo.

Se ci pensate, questo ha un senso, perché il sistema operativo è in fase di inizializzazione i dati solo per evitare che un'applicazione di accedere ai dati da un'altra applicazione. C'è meno rischio nel permettere ad un'applicazione di accedere ai propri dati, quindi per motivi di prestazioni l'inizializzazione non viene eseguita ogni volta - solo la prima volta che un particolare segmento di memoria è reso disponibile per l'uso dall'applicazione (in qualsiasi segmento).

A volte quando si esegue un'applicazione in modalità di debug, tuttavia, alcuni runtime della modalità di debug inizializzano i dati stack e heap ad ogni allocazione (quindi il campo Foo verrà sempre inizializzato). Tuttavia, diversi runtime di debug inizializzano i dati a valori diversi. Alcuni zero inizializzano e alcuni inizializzano con un valore di "marker".

Il punto è - mai e poi mai utilizzare i valori non inizializzati qualsiasi punto del codice. Non è assolutamente garantito che verranno azzerati. Inoltre, assicurati di leggere l'articolo precedentemente collegato relativo all'inizializzazione di parens e default vs value poiché questo influenza la definizione di un valore "non inizializzato".