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

Tengo esto struct:

struct Snapshot
{
    double x; 
    int y;
};

Quiero xy yser 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?

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 inicializar sin tener en cuenta su tipo: esa es la inicialización del valor, y generalmente produce un valor inicial adecuado (0 para int, 0.0 para doble, llamando al constructor predeterminado para el usuario definido tipos que tienen constructores declarados por el usuario, ...). Esto es importante especialmente si su estructura es una plantilla.

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

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

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

En general, no. Sin embargo, una estructura declarada como alcance de archivo o estática en una función / se inicializará a 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
}

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

En C ++, use constructores sin argumentos. En C no puede tener constructores, así que use uno memseto la solución interesante: inicializadores designados:

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

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.

Dado que este es un POD (esencialmente una estructura C), hay poco daño en inicializarlo de la manera C:

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

o de manera similar

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

Sin embargo, no iría tan lejos como para usarlo calloc()en un programa C ++.

Mueva los miembros del pod a una clase base para acortar su lista de inicializadores:

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