Werden Mitglieder einer C ++ - Struktur standardmäßig auf 0 initialisiert?

Ich habe das struct:

struct Snapshot
{
    double x; 
    int y;
};

Ich möchte xund ysoll 0 sein. Werden sie standardmäßig 0 sein oder muss ich Folgendes tun:

Snapshot s = {0,0};

Was sind die anderen Möglichkeiten, um die Struktur auf Null zu setzen?

Sie sind nicht null, wenn Sie die Struktur nicht initialisieren.

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

Der zweite macht alle Mitglieder auf Null, der erste lässt sie bei nicht spezifizierten Werten. Beachten Sie, dass es rekursiv ist:

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

Der zweite wird p.s.{x,y}Null machen . Sie können diese aggregierten Initialisierungslisten nicht verwenden, wenn Ihre Struktur Konstruktoren enthält. In diesem Fall müssen Sie diesen Konstruktoren eine ordnungsgemäße Initialisierung hinzufügen

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

Initialisiert sowohl x als auch y auf 0. Beachten Sie, dass Sie x(), y()sie unabhängig von ihrem Typ initialisieren können: Dies ist dann die Wertinitialisierung und ergibt normalerweise einen korrekten Anfangswert (0 für int, 0.0 für double, wobei der Standardkonstruktor für benutzerdefiniert aufgerufen wird Typen, die vom Benutzer deklarierte Konstruktoren haben, ...). Dies ist besonders wichtig, wenn Ihre Struktur eine Vorlage ist.

Nein, sie sind standardmäßig nicht 0. Der einfachste Weg, um sicherzustellen, dass alle Werte oder standardmäßig 0 sind, besteht darin, einen Konstruktor zu definieren

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

Dadurch wird sichergestellt, dass alle Verwendungen von Snapshot initialisierte Werte haben.

Im Allgemeinen nein. Eine als Dateibereich oder statisch in einer Funktion deklarierte Struktur wird jedoch auf 0 initialisiert (genau wie alle anderen Variablen dieser Bereiche):

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
}

Mit POD können Sie auch schreiben

Snapshot s = {};

Sie sollten memset in C ++ nicht verwenden, memset hat den Nachteil, dass ein Nicht-POD in der Struktur zerstört wird.

oder so:

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

Snapshot* s = init();

Verwenden Sie in C ++ Konstruktoren ohne Argumente. In C können Sie keine Konstruktoren haben, verwenden Sie also entweder memsetoder - die interessante Lösung - bestimmte Initialisierer:

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

Ich glaube, die richtige Antwort ist, dass ihre Werte undefiniert sind. Oft werden sie beim Ausführen von Debug-Versionen des Codes auf 0 initialisiert. Dies ist normalerweise nicht der Fall, wenn Release-Versionen ausgeführt werden.

Da dies ein POD (im Wesentlichen eine C-Struktur) ist, schadet es wenig, ihn auf C-Weise zu initialisieren:

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

oder ähnlich

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

Ich würde jedoch nicht so weit gehen, es calloc()in einem C ++ - Programm zu verwenden.

Verschieben Sie Pod-Mitglieder in eine Basisklasse, um Ihre Initialisierungsliste zu verkürzen:

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