Warum wird diese Schleife bei einigen Plattformen und nicht bei anderen ausgeführt?

Auf meinem laptop läuft Ubuntu 14.04, ist dieser code nicht zu brechen, es zum Abschluss ausgeführt. Auf meiner Schule computer mit CentOS 6.6, es läuft auch gut. Auf Windows 8.1, wird die Schleife nie beendet.

Was ist mehr seltsam ist, wenn ich zum Bearbeiten der bedingten der for Schleife: i <= 11 der code nur beendet, auf meinem laptop läuft Ubuntu. CentOS und Windows nie beendet.

Du hast gerade entdeckt, Speicher stampfen. Sie können mehr darüber Lesen Sie hier: Was ist ein "memory stomp"?

Beim zuordnen von int array[10],i;diese Variablen gehen in den Speicher (speziell, Sie sind auf dem Stapel reserviert, das ist ein Speicherblock, der im Zusammenhang mit der Funktion). array[] und i sind wahrscheinlich nebeneinander im Speicher. Es scheint, dass auf Windows 8.1, i befindet sich bei array[10]. Auf CentOS, i befindet sich bei array[11]. Und auf Ubuntu, ist es in keiner Stelle (vielleicht ist es bei array[-1]?).

Versuchen Sie, diese debugging-Anweisungen im code. Sollten Sie bemerken, dass nach iteration 10 oder 11, array[i] Punkte auf i.

#include <stdio.h>

int main() 
{ 
  int array[10],i; 

  printf ("array: %p, &i: %p\n", array, &i); 
  printf ("i is offset %d from array\n", &i - array);

  for (i = 0; i <=11 ; i++) 
  { 
    printf ("%d: Writing 0 to address %p\n", i, &array[i]); 
    array[i]=0; /*code should never terminate*/ 
  } 
  return 0; 
} 

InformationsquelleAutor der Antwort QuestionC

Was sollte der Letzte Lauf der Schleife,schreiben Sie array[10]aber es gibt nur 10 Elemente im array, nummeriert von 0 bis 9. Die C-Sprache-Spezifikation sagt, dass dies "undefined behavior". Was dies in der Praxis bedeutet ist, dass ein Programm versucht zu schreiben, um die int-großer Teil des Speichers liegt, wird sofort nach array im Speicher. Was dann geschieht, hängt davon ab, was es tut, in der Tat, es liegen, und diese hängt nicht nur vom Betriebssystem, aber um so mehr auf den compiler, auf den compiler-Optionen (wie-Optimierungs-Einstellungen), auf der Prozessor-Architektur, die auf den umliegenden code, etc. Es könnte auch variieren von Ausführung zu Ausführung, z.B. durch address space randomization (wahrscheinlich nicht auf dieses Spielzeug Beispiel, aber es passiert im wirklichen Leben). Einige Möglichkeiten sind:

• War die Lage nicht verwendet. Die Schleife endet in der Regel.
• Die Lage wurde für etwas benutzt, was geschah, haben den Wert 0. Die Schleife endet in der Regel.
• Der Lage, enthalten die Funktion die return-Adresse. Die Schleife endet ganz normal, aber dann stürzt das Programm ab, weil es versucht, den Sprung an die Adresse 0.
• Die Position enthält die variable i. Die Schleife nie beendet, weil i startet bei 0.
• Die Position enthält einige andere variable. Die Schleife endet ganz normal, aber dann "interessante" Dinge passieren.
• Der Lage ist eine ungültige Speicheradresse, z.B. weil array ist direkt am Ende einer Seite im virtuellen Speicher und die nächste Seite ist nicht zugeordnet.
• Dämonen Fliegen aus Ihrer Nase. Zum Glück haben die meisten Computer nicht über die nötige hardware.

Was du beobachtet hast, auf Windows war, dass der compiler beschlossen, die variable i sofort nach dem array im Speicher, so array[10] = 0 endete die Zuordnung zu i. Unter Ubuntu und CentOS, der compiler hat nicht Platz i es. Fast alle C-Implementierungen der Gruppe lokale Variablen im Speicher, auf einem Speicher-stackmit einer großen Ausnahme: einige lokale Variablen gesetzt werden können, die vollständig in registriert. Auch wenn die variable auf den Stapel, die Reihenfolge der Variablen wird bestimmt durch den compiler, und es kann, hängt nicht nur von der Reihenfolge in der Quell-Datei, sondern auch auf deren Typen (zur Vermeidung der Verschwendung von Speicher-alignment-constraints, die Löcher), auf Ihren Namen, auf einige hash-Wert verwendet, in der eine compiler-interne Datenstruktur, etc.

Wenn Sie möchten, um herauszufinden, was dein compiler entschieden haben, können Sie es sagen, zeigen Sie den assembler-code. Oh, und zu lernen, zu entziffern, assembler (es ist einfacher als es zu schreiben). Mit GCC (und einigen anderen Compilern, besonders in der Unix-Welt), übergeben Sie die option -S zu erzeugen assembler-code anstelle einer binären. Zum Beispiel, hier ist der assembler-Schnipsel für die Schleife aus kompilieren mit GCC auf amd64 mit der Optimierung option -O0 (keine Optimierung), mit Kommentaren, die manuell Hinzugefügt:

.L3:
    movl    -52(%rbp), %eax           ; load i to register eax
    cltq
    movl    $0, -48(%rbp,%rax,4)      ; set array[i] to 0
    movl    $.LC0, %edi
    call    puts                      ; printf of a constant string was optimized to puts
    addl    $1, -52(%rbp)             ; add 1 to i
.L2:
    cmpl    $10, -52(%rbp)            ; compare i to 10
    jle     .L3

Hier die variable i ist 52 bytes unterhalb der Spitze des Stapels, während der array beginnt 48 bytes unterhalb der Spitze des Stapels. So ist dieser compiler das zufällig platziert i kurz vor dem array, man würde Sie überschreiben i wenn Sie geschehen, zu schreiben, zu array[-1]. Wenn Sie ändern array[i]=0 zu array[9-i]=0 haben, erhalten Sie eine Endlosschleife auf dieser besonderen Plattform, die mit diesen speziellen compiler-Optionen.

Lassen Sie uns nun kompilieren Sie Ihr Programm mit gcc -O1.

    movl    $11, %ebx
.L3:
    movl    $.LC0, %edi
    call    puts
    subl    $1, %ebx
    jne     .L3

Kürzeren! Der compiler hat nicht nur abgelehnt reservieren Sie einen Stapel Position für i — es ist immer nur in einem register gespeichert ebx — aber es ist noch nicht die Mühe gemacht zu allokieren von Speicher für die arrayoder um code zu generieren, um seine Elemente, weil es bemerkt, dass keines der Elemente immer verwendet.

Um in diesem Beispiel mehr erzählen, lassen Sie uns sicherstellen, dass die array-Zuweisungen werden ausgeführt, indem der compiler mit etwas, das es nicht in der Lage ist, zu optimieren, entfernt. Eine einfache Möglichkeit dafür ist die Verwendung des array aus einer anderen Datei — aufgrund der separaten Zusammenstellung der compiler nicht weiß, was passiert, in einer anderen Datei (es sei denn, es optimiert zur link-Zeit, die gcc -O0 oder gcc -O1 nicht). Erstellen Sie eine Quelldatei use_array.c mit

void use_array(int *array) {}

und ändern Sie Ihren source-code zu

#include <stdio.h>
void use_array(int *array);

int main()
{
  int array[10],i;

  for (i = 0; i <=10 ; i++)
  {
    array[i]=0; /*code should never terminate*/
    printf("test \n");

  }
  printf("%zd \n", sizeof(array)/sizeof(int));
  use_array(array);
  return 0;
}

Kompilieren mit

gcc -c use_array.c
gcc -O1 -S -o with_use_array1.c with_use_array.c use_array.o

Dieser Zeit der assembler-code sieht wie folgt aus:

    movq    %rsp, %rbx
    leaq    44(%rsp), %rbp
.L3:
    movl    $0, (%rbx)
    movl    $.LC0, %edi
    call    puts
    addq    $4, %rbx
    cmpq    %rbp, %rbx
    jne     .L3

Nun das array auf dem stack, 44 bytes von der Spitze. Was i? Es scheint nicht überall! Aber der Schleifenzähler wird gehalten in das register rbx. Es ist nicht genau iaber die Adresse des array[i]. Der compiler hat entschieden, dass, da der Wert der i war nie direkt verwendet, es wurde kein Punkt in der Arithmetik zu berechnen, wo zu speichern 0 bei jedem Durchlauf der Schleife. Statt, die Adresse ist die loop-variable, und die Arithmetik für die Bestimmung der Grenzen erfolgte teilweise zur compile-Zeit (multiplizieren 11 Iterationen von 4 bytes pro array-element zu erhalten 44) und teilweise zur Laufzeit, aber für alle mal, bevor die Schleife gestartet wird (führen Sie eine Subtraktion um den ursprünglichen Wert).

Selbst bei diesem sehr einfachen Beispiel haben wir gesehen, wie verändert der compiler-Optionen (einschalten-Optimierung) oder ändern etwas kleinere (array[i] zu array[9-i]) oder auch der Wechsel etwas scheinbar nicht (hinzufügen der Aufruf use_array) kann einen erheblichen Unterschied zu dem, was in dem ausführbaren Programm, der vom compiler erzeugt hat. Compiler-Optimierungen kann eine Menge Dinge tun, die angezeigt werden können unintuitiv, die an Programmen aufrufen zu undefiniertem Verhalten. Das ist, warum Undefiniertes Verhalten ist vollkommen undefiniert. Wenn Sie abweichen, immer so leicht von den Gleisen, in real-world-Programme, es kann sehr hart sein, zu verstehen, die Beziehung zwischen dem, was der code tut und was Sie getan haben sollte, sogar für erfahrene Programmierer.

InformationsquelleAutor der Antwort Gilles

Haben Sie eine bounds violation, und auf die nicht-terminierende Plattformen, ich glaube, Sie sind versehentlich die Einstellung i auf null am Ende der Schleife, so dass es immer wieder startet.

array[10] ist ungültig; Sie enthält 10 Elemente, die array[0] durch array[9]und array[10] ist der 11. Die Schleife geschrieben werden sollen, zu stoppen vor 10 wie folgt:

for (i = 0; i < 10; i++)

Wo array[10] Länder wird durch die Implementierung festgelegt und lustig, auf beiden Plattformen ein, landet er auf idie diese Plattformen offenbar lag direkt nach array. i auf null gesetzt und die Schleife wiederholt sich immer. Für die anderen Plattformen i kann sich vor array oder array können einige Polsterung nach.

InformationsquelleAutor der Antwort Derek T. Jones

Ist es undefiniert, bei array[10]und gibt Undefiniertes Verhaltenwie vorher beschrieben. Denken Sie daran, wie diese:

Ich habe 10 Artikel in meinem Einkaufswagen. Sie sind:

0: Ein Feld von Getreide

1: Brot

2: Milch

3: Pie

4: Eier

5: Kuchen

6: Einen 2-liter-soda

7: Salat

8: Burger

9: Eis

cart[10] ist nicht definiert und kann eine out of bounds exception in einigen Compilern. Aber viele scheinbar nicht. Die scheinbare 11th Element ist ein Element nicht tatsächlich in den Warenkorb gelegt. Die 11th Element verweist, was ich nenne, eine "poltergeist Element." Es nie gegeben, aber es war da.

Warum einige Compiler geben i einen index von array[10] oder array[11] oder sogar array[-1] aufgrund Ihrer Initialisierung/Deklarationsanweisung. Manche Compiler interpretieren dies als:

• "Allocate 10 Blöcke von ints für array[10] und anderen int block. um es einfacher zu machen, legte Sie direkt neben einander."
• Gleiche wie zuvor, bewegen sich aber es ein Raum oder zwei Weg, so dass die array[10] nicht auf i.
• Das gleiche tun wie zuvor, belegen aber i bei array[-1] (weil ein index eines Arrays kann nicht, oder sollte nicht negativ sein), oder weisen Sie es an einem völlig anderen Ort, weil das OS damit umgehen kann, und es ist sicherer.

Einige Compiler wollen die Dinge gehen schneller, und einige Compiler lieber die Sicherheit. Es ist alles über Kontext. Wenn ich eine app zu entwickeln für die alte BREW-OS (die OS eine grundlegende Telefon), zum Beispiel, es wäre nicht die Sorge um die Sicherheit. Wenn ich die Entwicklung für ein iPhone 6 ist, dann könnte es schnell laufen, egal was, ich bräuchte also einen Schwerpunkt auf die Sicherheit. (Im ernst, haben Sie gelesen apples App Store-Richtlinien, oder Lesen, auf die Entwicklung von Swift und Swift 2.0?)

InformationsquelleAutor der Antwort DDPWNAGE

Gut, C-compiler, die traditionell nicht überprüfen Sie für Grenzen. Sie können einen "segmentation fault" den Fall, Sie beziehen sich auf eine Lage, die nicht "dazugehören", um Ihren Prozess. Jedoch werden die lokalen Variablen zugewiesen werden, auf den stack und abhängig davon, wie der Speicher reserviert, der Bereich direkt hinter dem array (array[10]) gehört zu den Prozess-Speicher-segment. Also, keine " segmentation fault trap wird ausgelöst, und das ist das, was Sie scheinen zu erleben. Wie andere haben darauf hingewiesen, das ist Undefiniertes Verhalten in C und der code kann als unberechenbar. Da lernen Sie C, Sie sind besser dran, bekommen in der Gewohnheit der überprüfung für die Grenzen in Ihrem code.

InformationsquelleAutor der Antwort unxnut

Wenn Sie Durchlaufen Vergangenheit i==9 weisen Sie null, um die "array-Elemente", die sich eigentlich Vergangenheit arrayso sind Sie overwritnig einige andere Daten. Wahrscheinlich überschreiben Sie die i variable, die sich nach a[]. So können Sie einfach zurücksetzen der i variable auf null und so starten Sie den loop.

Können Sie entdecken, dass Sie sich, wenn Sie gedruckt i in der Schleife:

      printf("test i=%d\n", i);

statt nur

      printf("test \n");

Natürlich, das Ergebnis hängt sehr stark von der Zuweisung von Speicher für die Variablen, die wiederum abhängig von einem compiler und dessen Einstellungen, so ist es in der Regel Undefiniertes Verhalten — das ist der Grund, warum die Ergebnisse auf verschiedenen Rechnern oder verschiedenen Betriebssystemen oder auf unterschiedlichen Compilern unterscheiden können.

InformationsquelleAutor der Antwort CiaPan

Werde ich vorschlagen, etwas, dass ich die Kraft finden über:

Versuchen zuweisen array[i] = 20;

Ich denke, das beendet werden soll, den code überall.. (Sie halten i< =10 oder ll)

Wenn diese ausgeführt wird, können Sie entscheiden, fest, dass die festgelegten Antworten hier sind schon richtig [die Antwort bezüglich des Speichers stampfen, eine für die ex.]

InformationsquelleAutor der Antwort Raining fire