todas - ¿Los miembros de una estructura de C++ están inicializados a 0 por defecto?

funciones en c++ ejemplos

Question

Tengo esta struct :

struct Snapshot
{
    double x; 
    int y;
};

Quiero que x sean 0. ¿Serán 0 por defecto o tengo que hacerlo?

Snapshot s = {0,0};

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

Answer 1

Como esto 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 similarmente

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

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

Answer 2

Con POD también puedes escribir

Snapshot s = {};

No deberías 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();

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 C ++, use constructores sin argumentos. En C no puedes tener constructores, así que usa memset o - la solución interesante - inicializadores designados:

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

Answer 5

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

Answer 6

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

Answer 7

No son nulos si no inicializas 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á que ps{x,y} cero. No puede usar estas listas de inicializadores agregados si tiene constructores en su estructura. Si ese es el caso, tendrá que agregar una iniciació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: entonces es la inicialización de valor, y generalmente da un valor inicial adecuado (0 para int, 0.0 para doble, llamando al constructor predeterminado para los tipos definidos por el usuario que tienen constructores declarados por el usuario, ...). Esto es importante especialmente si su estructura es una plantilla.

Answer 8

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

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

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