¿Los miembros de una estructura de C++ están inicializados en 0 de forma predeterminada?

Question

tengo unas pocas cosas struct:

struct Snapshot 
    { 
     double x; 
     int y ; 

    }; 

Quiero x y y a ser 0. Serán 0 por defecto o tengo que hacer:

Snapshot s= {0,0}; 

¿Cuáles son las otras formas de cero fuera de la estructura?

Answer 1

No son nulas si no inicializa la estructura.

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

El segundo hará que todos los miembros sean cero, el primero los deja en valores no especificados. Tenga en cuenta que es recursivo:

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

El segundo hará p.s.{x,y} cero. No puede usar estas listas de inicializadores agregados si tiene constructores en su estructura. Si ese es el caso, se le tiene que añadir initalization adecuada a esos constructores

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

inicializará tanto x como y a 0. Obsérvese que se puede utilizar x(), y() inicializarlas haciendo caso omiso de su tipo: Eso es entonces el valor de inicialización , y generalmente produce un valor inicial adecuado (0 para int, 0.0 para double, llamando al constructor predeterminado para tipos definidos por el usuario que tienen constructores declarados por el usuario, ...). Esto es importante especialmente si su estructura es una plantilla.

Answer 2

No, no son 0 por defecto. La forma más sencilla de asegurarse de que todos los valores o en default a 0 es definir un constructor

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

Esto asegura que todos los usos de Snapshot tendrán valores inicializados.

Answer 3

Creo que la respuesta correcta es que sus valores no están definidos. A menudo, se inicializan a 0 cuando se ejecutan versiones de depuración del código. Este no suele ser el caso cuando se ejecutan versiones de lanzamiento.

Answer 4

En general, no. Sin embargo, una estructura declarada como archivo-alcance o estática en una función/será/ser inicializado a 0 (al igual que todas las otras variables de aquellos ámbitos):

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

Dado que este es un POD (esencialmente un struct C) hay poco daño en la inicialización de la manera C:

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

o similarmente

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

yo no iría tan lejos como para usar calloc() en un programa en C++ sin embargo.

Answer 6

En C++, utilice constructores sin argumento.En C no se puede tener constructores, a fin de utilizar ya sea memset o - la solución interesante - inicializadores designados:

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

Answer 7

Con POD también se puede escribir

Snapshot s = {}; 

no debería utilizar memset en C++ , memset tiene el inconveniente de que si hay un no-POD en la estructura lo destruirá.

o como esto:

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

Snapshot* s = init(); 

Answer 8

miembros Mover vaina a una clase base para acortar su lista de inicialización:

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()); 
}