Anfangswert des int-Arrays in C

Wenn Sie ein Array in C wie folgt deklarieren:

int array[10];

Was ist der Anfangswert der ganzen Zahlen? Ich erhalte unterschiedliche Ergebnisse mit verschiedenen Compilern und möchte wissen, ob es etwas mit dem Compiler oder dem Betriebssystem zu tun hat.

Wenn das Array in einer Funktion deklariert ist, ist der Wert undefiniert. int x[10]; in einer Funktion bedeutet: den Besitz eines 10-int-großen Speicherbereichs übernehmen, ohne eine Initialisierung durchzuführen. Wenn das Array als global oder als deklariert ist static in einer Funktion werden alle Elemente auf Null initialisiert, wenn sie nicht bereits initialisiert sind.

Standardmäßig werden alle globalen und funktionsstatischen Variablen automatisch auf 0 initialisiert. Automatische Variablen werden nicht initialisiert.

int a[10];  // global - all elements are initialised to 0

void foo(void) {
    int b[10];    // automatic storage - contain junk
    static int c[10]; // static - initialised to 0
}

Es empfiehlt sich jedoch, die Funktionsvariable unabhängig von ihrer Speicherklasse immer manuell zu initialisieren. Um alle Array-Elemente auf 0 zu setzen, müssen Sie nur das erste Array-Element auf 0 zuweisen – ausgelassene Elemente werden automatisch auf 0 gesetzt:

int b[10] = {0};

Warum sind Funktionslokale (auto Speicherklasse) nicht initialisiert, wenn alles andere ist?

C ist nahe an der Hardware; das ist seine größte Stärke und seine größte Gefahr. Der Grund auto Speicherklassenobjekte haben zufällige Anfangswerte, weil sie auf dem Stapel zugewiesen werden und eine Entwurfsentscheidung getroffen wurde, diese nicht automatisch zu löschen (teilweise, weil sie bei jedem Funktionsaufruf gelöscht werden müssten).

Andererseits sind die Nicht-auto Objekte müssen nur einmal geräumt werden. Außerdem muss das Betriebssystem zugewiesene Seiten aus Sicherheitsgründen ohnehin löschen. Die Entwurfsentscheidung bestand hier also darin, die Nullinitialisierung anzugeben. Warum ist die Sicherheit beim Stack nicht auch ein Thema? Eigentlich ist es erstmal geräumt. Der Müll, den Sie sehen, stammt von früheren Instanzen der Aufrufrahmen Ihres eigenen Programms und dem von ihnen aufgerufenen Bibliothekscode.

Das Endergebnis ist schneller, speichereffizienter Code. Alle Vorteile der Montage ohne Schmerzen. Bevor dmr C erfand, wurden “HLL”s wie Basic und ganze OS-Kernel wirklich, buchstäblich, als riesige Assembler-Programme implementiert. (Mit bestimmten Ausnahmen an Orten wie IBM.)

Gemäß der C-Norm, 6.7.8 (Anmerkung 10):

Wenn ein Objekt mit automatischer Speicherdauer nicht explizit initialisiert wird, ist sein Wert unbestimmt.

Es kommt also auf den Compiler an. Mit MSVC initialisieren Debug-Builds automatische Variablen mit 0xcc, während Nicht-Debug-Builds diese Variablen überhaupt nicht initialisieren.

Die AC-Variablendeklaration weist den Compiler lediglich an, einen Speicherbereich für Sie zu reservieren und zu benennen. Bei automatischen Variablen, auch Stack-Variablen genannt, werden die Werte in diesem Speicher gegenüber dem vorherigen nicht geändert. Globale und statische Variablen werden beim Programmstart auf Null gesetzt.

Einige Compiler im nicht optimierten Debug-Modus setzen automatische Variablen auf Null. Bei neueren Compilern ist es jedoch üblich geworden, die Werte auf einen bekannten schlechten Wert zu setzen, damit der Programmierer nicht unwissentlich Code schreibt, der davon abhängt, dass eine Null gesetzt wird.

Um den Compiler zu bitten, ein Array für Sie auf Null zu setzen, können Sie es wie folgt schreiben:

int array[10] = {0};

Noch besser ist es, das Array mit den Werten zu setzen, die es haben sollte. Das ist effizienter und vermeidet das doppelte Schreiben in das Array.

In den meisten neuesten Compilern (z. B. gcc/vc++) werden teilweise initialisierte lokale Array-/Strukturmitglieder standardmäßig auf null (int), NULL (char/char-String), 0,000000 (float/double) initialisiert.

Abgesehen von lokalen Array-/Strukturdaten wie oben behalten auch statische (global/lokal) und globale Raummitglieder dieselbe Eigenschaft bei.

int a[5] = {0,1,2};
printf("%d %d %d\n",*a, *(a+2), *(a+4));

struct s1
{
int i1;
int i2;
int i3;
char c;
char str[5];
};

struct s1 s11 = {1};
    printf("%d %d %d %c %s\n",s11.i1,s11.i2, s11.i3, s11.c, s11.str);
    if(!s11.c)
        printf("s11.c is null\n");
    if(!*(s11.str))
        printf("s11.str is null\n");

In gcc/vc++ sollte die Ausgabe sein:

0 2 0 1 0 0 0,000000 s11.c ist null s11.str ist null

Texte von http://www.cplusplus.com/doc/tutorial/arrays/

ZUSAMMENFASSUNG:

Arrays initialisieren. Wenn wir ein reguläres Array mit lokalem Geltungsbereich (z. B. innerhalb einer Funktion) deklarieren und nichts anderes angeben, werden seine Elemente standardmäßig mit keinem Wert initialisiert, sodass ihr Inhalt unbestimmt ist, bis wir einen Wert in ihnen speichern. Die Elemente globaler und statischer Arrays werden dagegen automatisch mit ihren Defaultwerten initialisiert, was für alle fundamentalen Typen bedeutet, dass sie mit Nullen aufgefüllt werden.

In beiden Fällen, lokal und global, haben wir bei der Deklaration eines Arrays die Möglichkeit, jedem seiner Elemente Anfangswerte zuzuweisen, indem wir die Werte in geschweiften Klammern { } einschließen. Zum Beispiel:

int billy [5] = { 16, 2, 77, 40, 12071 };