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

Question

Ho questo struct:

struct Snapshot 
    { 
     double x; 
     int y ; 

    }; 

voglio x e y a 0. Saranno 0 per default o devo fare:

Snapshot s= {0,0}; 

Quali sono gli altri modi a zero fuori la struttura?

Answer 1

Non sono nulli se non si inizializza la struttura.

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

La seconda farà tutti i membri nullo, 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à p.s.{x,y} zero. Non puoi usare questi elenchi di inizializzatori aggregati se hai costruttori nella tua struct. Se questo è il caso, si dovrà aggiungere una corretta inizializzazione del a quei costruttori

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

inizializza xey a 0. Si noti che è possibile utilizzare x(), y() per inizializzare loro senza tener conto del loro tipo: Che è poi l'inizializzazione valore e di solito restituisce un valore iniziale appropriato (0 per int, 0.0 per double, chiamando il costruttore predefinito per i tipi definiti dall'utente che hanno costruttori dichiarati dall'utente, ...). Questo è importante specialmente se la tua struttura è un modello.

Answer 2

No, non sono 0 di default. Il modo più semplice per garantire che tutti i valori o stabilizzato a 0 è quello di definire un costruttore

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

Ciò garantisce che tutti gli usi di istantanee avranno valori inizializzati.

Answer 3

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.

Answer 4

In generale, n. Tuttavia, una struttura dichiarata nel formato-scope o statico in una funzione/sarà/inizializzato a 0 (come tutte le altre variabili di tali 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 
} 

Answer 5

Poiché questo è un POD (essenzialmente un C struct) c'è poco danno in inizializzazione nel modo C:

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

né parimenti

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

non vorrei andare fino al punto di usare calloc() in un programma C++ però.

Answer 6

In C++, utilizzare costruttori senza argomento.In C non si può avere costruttori, in modo da utilizzare sia memset o - la soluzione interessante - inizializzatori designati:

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

Answer 7

Con il POD è possibile anche scrivere

Snapshot s = {}; 

Non si deve usare memset in C++ , memset ha lo svantaggio che se c'è un non-POD nella struttura lo distruggerà.

o come questo:

struct init 
{ 
    template <typename T> 
    operator T *() 
    { 
    return new T(); 
    } 
}; 

Snapshot* s = init(); 

Answer 8

membri Spostare Pod to una classe base per accorciare la lista 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", f.x, f.y, f.z, f.name.c_str()); 
}