Czy członkowie struktury C++ są domyślnie inicjowani na 0?

Question

mam to struct:

struct Snapshot 
    { 
     double x; 
     int y ; 

    }; 

Chcę x i y być 0. Będą 0 domyślnie lub trzeba zrobić:

Snapshot s= {0,0}; 

Jakie są inne sposoby na zero poza strukturą?

Answer 1

Nie są one zerowe, jeśli nie zainicjalizujesz struktury.

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

Drugi powoduje, że wszystkie elementy są zerowe, a pierwszy pozostawia je w nieokreślonych wartościach. Zauważ, że jest rekurencyjna:

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

Drugi uczyni p.s.{x,y} zerowy. Nie możesz użyć tych agregujących list inicjalizujących, jeśli masz konstruktory w swojej strukturze. Jeśli tak jest, trzeba będzie dodać właściwą initalization tych konstruktorów

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

zainicjuje X i Y 0. Zauważ, że możesz użyć x(), y() zainicjować je bez uwzględnienia ich typu: To wtedy inicjalizacji wartość i zwykle daje właściwą wartość początkową (0 dla int, 0.0 dla double, wywołanie domyślnego konstruktora dla typów zdefiniowanych przez użytkownika, które mają deklarowane konstruktory, ...). Jest to szczególnie ważne, jeśli struktura jest szablonem.

Answer 2

Nie, domyślnie nie mają wartości 0. Najprostszy sposób, aby zapewnić, że wszystkie wartości 0 lub domyślne jest określenie konstruktora

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

Zapewnia to, że wszystkie zastosowania Migawka inicjalizacji wartości.

Answer 3

Wierzę, że poprawna odpowiedź jest taka, że ​​ich wartości są niezdefiniowane. Często są one inicjalizowane na 0 podczas uruchamiania wersji debugowania kodu. Zwykle nie jest tak w przypadku wersji uruchomionych.

Answer 4

Ogólnie rzecz biorąc nie. Jednakże, struktura uznane jako plik-zakresu lub statycznych funkcji/będzie/jest ustawiony na 0 (podobnie jak wszystkie inne zmienne tych zakresów):

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 5

Ponieważ jest POD (zasadniczo C Struct) niewiele jest złego w inicjalizacji to tak C:

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

lub podobnie

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

nie chciałbym iść tak daleko, aby korzystać calloc() w programie C++ mimo.

Answer 6

W C++ użyj konstruktów bezargumentowych.W C nie można mieć konstruktorów, więc użyć memset lub - ciekawe rozwiązanie - część przeznaczona inicjalizatory:

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

Answer 7

Z POD można również napisać

Snapshot s = {}; 

Nie należy używać memset w C++ , memset ma tę wadę, że jeśli w strukturze jest nie-POD, to go zniszczy.

lub tak:

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

Snapshot* s = init(); 

Answer 8

członków Move strąk do klasy bazowej, aby skrócić listę initializer:

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