¿Los miembros de una estructura de C++ se inicializan en 0 de forma predeterminada?

Question 1

tengo esto 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 poner a cero la estructura?

Question 2

No son nulos 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, deberá agregar la inicialización 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. Tenga en cuenta que puede usar x(), y() para inicializarlos sin tener en cuenta su tipo: eso es entonces la inicialización del valor, y generalmente produce un valor inicial adecuado (0 para int, 0.0 para doble, 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.

Question 3

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

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

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

Question 4

En general, no. Sin embargo, una estructura declarada como ámbito de archivo o estática en una función /se/se inicializará en 0 (al igual que todas las demás variables de esos á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
}

Question 5

Con POD también puedes escribir

Snapshot s = {};

No debe usar memset en C ++, memset tiene el inconveniente de que si hay un no POD en la estructura, lo destruirá.

o así:

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

Snapshot* s = init();

Question 6

En C++, use constructores sin argumentos. En C no puedes tener constructores, así que usa cualquiera memset o – la solución interesante – inicializadores designados:

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

Question 7

Dado que se trata de un POD (esencialmente una estructura C), hay poco daño al inicializarlo de la manera C:

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

o similar

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

Yo no iría tan lejos como para usar calloc() aunque en un programa C++.

Question 8

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

¿Ha sido útil esta solución?