Les membres d'une structure C++ sont-ils initialisés à 0 par défaut ?

Question

J'ai ceci struct :

   struct Snapshot
    {
        double x; 
        int   y ;

    };

Je veux x et y seront 0. Seront-ils 0 par défaut ou dois-je faire :

Snapshot s= {0,0};

Quelles sont les autres façons de remettre la structure à zéro ?

Answer 1

Ils ne sont pas nuls si vous n'initialisez pas la structure.

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

La seconde rendra tous les membres nuls, la première les laisse à des valeurs non spécifiées. Notez que c'est récursif :

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

Le second fera p.s.{x,y} zéro. Vous ne pouvez pas utiliser ces listes d'initialisation agrégées si vous avez des constructeurs dans votre structure. Si c'est le cas, vous devrez ajouter l'initialisation appropriée à ces constructeurs

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

initialisera x et y à 0. Notez que vous pouvez utiliser x(), y() pour les initialiser sans tenir compte de leur type : C'est alors l'initialisation de la valeur, et cela donne généralement une valeur initiale correcte (0 pour int, 0.0 pour double, appel du constructeur par défaut pour les types définis par l'utilisateur qui ont des constructeurs déclarés par l'utilisateur, ...). Ceci est important, surtout si votre structure est un modèle.

Answer 2

Non, ils ne sont pas 0 par défaut. La manière la plus simple de s'assurer que toutes les valeurs sont par défaut à 0 est de définir un constructeur

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

Cela garantit que toutes les utilisations de Snapshot auront des valeurs initialisées.

Answer 3

En général, non. Cependant, une structure déclarée comme file-scope ou static dans une fonction sera initialisée à 0 (comme toutes les autres variables de ces scopes) :

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 4

Avec POD, vous pouvez également écrire

Snapshot s = {};

Vous ne devriez pas utiliser memset en C++, memset a l'inconvénient que s'il y a un non-POD dans la structure, il la détruira.

ou comme ça :

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

Snapshot* s = init();

Answer 5

En C++, utilisez des constructeurs sans argument. En C, vous ne pouvez pas avoir de constructeurs, alors utilisez soit memset ou - la solution intéressante - des initialisateurs désignés :

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