I membri di una struct C ++ sono inizializzati su 0 per impostazione predefinita?

Ho questa struct :

 struct Snapshot { double x; int y; }; 

Voglio che x e y siano 0. Saranno 0 di default o devo fare:

 Snapshot s = {0,0}; 

Quali sono gli altri modi per azzerare la struttura?

Non sono nulli se non si inizializza la struttura.

 Snapshot s; // receives no initialization Snapshot s = {}; // value initializes all members 

Il secondo farà sì che tutti i membri siano zero, il primo li lascia a valori non specificati. Si noti che è ricorsivo:

 struct Parent { Snapshot s; }; Parent p; // receives no initialization Parent p = {}; // value initializes all members 

Il secondo farà ps{x,y} zero. Non puoi usare questi elenchi di inizializzatori aggregati se hai costruttori nella tua struct. Se questo è il caso, dovrai aggiungere l’idonea initalization a quei costruttori

 struct Snapshot { int x; double y; Snapshot():x(0),y(0) { } // other ctors / functions... }; 

Inizializzerà sia x che y su 0. Si noti che è ansible utilizzare x(), y() per inizializzarli ignorando il loro tipo: Questa è quindi l’inizializzazione del valore e di solito restituisce un valore iniziale corretto (0 per int, 0.0 per doppio, chiamare il costruttore predefinito per i tipi definiti dall’utente che hanno costruttori dichiarati dall’utente, …). Questo è importante specialmente se la tua struttura è un modello.

No, non sono 0 di default. Il modo più semplice per garantire che tutti i valori o il valore predefinito a 0 sia definire un costruttore

 Snapshot() : x(0), y(0) { } 

Ciò garantisce che tutti gli usi di Snapshot abbiano valori inizializzati.

In generale, no. Tuttavia, una struct dichiarata come scope del file o statica in una funzione / sarà / inizializzata a 0 (proprio come tutte le altre variabili di quegli ambiti):

 int x; // 0 int y = 42; // 42 struct { int a, b; } foo; // 0, 0 void foo() { struct { int a, b; } bar; // undefined static struct { int c, d; } quux; // 0, 0 } 

Con POD puoi anche scrivere

 Snapshot s = {}; 

Non si dovrebbe usare memset in C ++, memset ha lo svantaggio che se c’è un non POD nella struct lo distruggerà.

o in questo modo:

 struct init { template  operator T * () { return new T(); } }; Snapshot* s = init(); 

In C ++, usa costruttori senza argomenti. In C non puoi avere costruttori, quindi usa memset o – la soluzione interessante – inizializzatori designati:

 struct Snapshot s = { .x = 0.0, .y = 0.0 }; 

Poiché si tratta di un POD (essenzialmente una struttura C), l’inizializzazione del modo C non è un problema:

 Snapshot s; memset(&s, 0, sizeof (s)); 

o allo stesso modo

 Snapshot *sp = new Snapshot; memset(sp, 0, sizeof (*sp)); 

Non andrei così lontano da usare calloc() in un programma C ++.

Credo che la risposta corretta sia che i loro valori non sono definiti. Spesso, vengono inizializzati su 0 quando si eseguono versioni di debug del codice. Questo di solito non è il caso quando si eseguono versioni di rilascio.

Spostare i membri del pod su una class base per abbreviare l’elenco di inizializzazione:

 struct foo_pod { int x; int y; int z; }; struct foo : foo_pod { std::string name; foo(std::string name) : foo_pod() , name(name) { } }; int main() { foo f("bar"); printf("%d %d %d %s\n", fx, fy, fz, f.name.c_str()); }