Wie setzt Array [100] = {0} das gesamte Array auf 0?

Wie füllt der Compiler Werte aus char array[100] = {0};? Was ist die Magie dahinter?

Ich wollte wissen, wie der interne Compiler initialisiert wird.

Es ist keine Magie.

Das Verhalten dieses Codes in C wird in Abschnitt 6.7.8.21 der C-Spezifikation ( Online-Entwurf der C-Spezifikation ) beschrieben: Für die Elemente, die keinen angegebenen Wert haben, initialisiert der Compiler Zeiger auf NULL und arithmetische Typen auf Null ( und wendet dies rekursiv auf Aggregate an).

Das Verhalten dieses Codes in C ++ wird in Abschnitt 8.5.1.7 der C ++ - Spezifikation ( Online-Entwurf der C ++ - Spezifikation ) beschrieben: Das Compiler-Aggregat initialisiert die Elemente, die keinen bestimmten Wert haben.

Beachten Sie außerdem, dass Sie in C ++ (aber nicht in C) eine leere Initialisierungsliste verwenden können, wodurch der Compiler alle Elemente des Arrays aggregiert und initialisiert:

char array[100] = {};

Schauen Sie sich die folgende Frage an, welche Art von Code der Compiler dabei generieren könnte: Seltsame Assembly aus der Array-0-Initialisierung

Die Implementierung liegt bei den Compiler-Entwicklern.

Wenn Ihre Frage lautet "Was passiert mit einer solchen Deklaration?", Setzt der Compiler das erste Array-Element auf den von Ihnen angegebenen Wert (0) und alle anderen werden auf Null gesetzt, da dies ein Standardwert für ausgelassene Array-Elemente ist.

Wenn Ihr Compiler GCC ist, können Sie auch die folgende Syntax verwenden:

int array[256] = {[0 ... 255] = 0};

Bitte schauen Sie unter http://gcc.gnu.org/onlinedocs/gcc-4.1.2/gcc/Designated-Inits.html#Designated-Inits nach und beachten Sie, dass dies eine compilerspezifische Funktion ist.

Es hängt davon ab, wo Sie diese Initialisierung platzieren.

Wenn das Array statisch ist wie in

char array[100] = {0};

int main(void)
{
...
}

dann ist es der Compiler, der die 100 0 Bytes im Datensegment des Programms reserviert. In diesem Fall hätten Sie den Initialisierer weglassen können.

Wenn Ihr Array automatisch ist, ist es eine andere Geschichte.

int foo(void)
{
char array[100] = {0};
...
}

In diesem Fall haben Sie bei jedem Aufruf der Funktion foo ein verstecktes Memset.

Der obige Code entspricht

int foo(void)
{ 
char array[100];

memset(array, 0, sizeof(array));
....
}

und wenn Sie den Initialisierer weglassen, enthält Ihr Array zufällige Daten (die Daten des Stapels).

Wenn Ihr lokales Array wie in statisch deklariert ist

int foo(void)
{ 
static char array[100] = {0};
...
}

dann ist es technisch der gleiche Fall wie beim ersten.