Funktionieren Klammern in C als Stapelrahmen?

Wenn ich eine Variable innerhalb eines neuen Satzes von geschweiften Klammern erstelle, ist diese Variable dann auf der schließenden Klammer vom Stapel gefallen oder hängt sie bis zum Ende der Funktion? Beispielsweise:

void foo() {
   int c[100];
   {
       int d[200];
   }
   //code that takes a while
   return;
}

Wird dwährend des code that takes a whileAbschnitts Speicherplatz beanspruchen?

Nein, geschweifte Klammern fungieren nicht als Stapelrahmen. In C bezeichnen geschweifte Klammern nur einen Namensbereich, aber nichts wird zerstört und nichts wird vom Stapel gesprungen, wenn die Kontrolle darüber ausfällt.

Als Programmierer, der Code schreibt, kann man sich das oft so vorstellen, als wäre es ein Stapelrahmen. Die in den geschweiften Klammern deklarierten Bezeichner sind nur innerhalb der geschweiften Klammern zugänglich. Aus Sicht eines Programmierers ist es also so, als würden sie beim Deklarieren auf den Stapel geschoben und dann beim Verlassen des Bereichs geöffnet. Compiler müssen jedoch keinen Code generieren, der beim Ein- / Ausstieg etwas pusht / platzt (und im Allgemeinen auch nicht).

Beachten Sie auch, dass lokale Variablen möglicherweise überhaupt keinen Stapelspeicher belegen: Sie können in CPU-Registern oder an einem anderen zusätzlichen Speicherort gespeichert oder vollständig optimiert werden.

dTheoretisch könnte das Array also Speicher für die gesamte Funktion verbrauchen. Der Compiler kann es jedoch optimieren oder seinen Speicher mit anderen lokalen Variablen teilen, deren Nutzungsdauer sich nicht überschneidet.

Die Zeit, in der die Variable tatsächlich Speicher belegt, ist offensichtlich vom Compiler abhängig (und viele Compiler passen den Stapelzeiger nicht an, wenn innere Blöcke innerhalb von Funktionen eingegeben und verlassen werden).

Eine eng verwandte, aber möglicherweise interessantere Frage ist jedoch, ob das Programm auf dieses innere Objekt außerhalb des inneren Bereichs (aber innerhalb der enthaltenden Funktion) zugreifen darf, dh:

void foo() {
   int c[100];
   int *p;

   {
       int d[200];
       p = d;
   }

   /* Can I access p[0] here? */

   return;
}

(Mit anderen Worten: Darf der Compiler die Zuordnung aufheben d, auch wenn dies in der Praxis die meisten nicht tun?)

Die Antwort ist , dass der Compiler ist ausplanen erlaubt d, und den Zugriff auf, p[0]wo der Kommentar angibt , nicht definiertes Verhalten (das Programm ist nicht das innere Objekt außerhalb des inneren Umfangs für den Zugriff erlaubt). Der relevante Teil des C-Standards ist 6.2.4p5:

Für ein solches Objekt [eines Objekts mit automatischer Speicherdauer] ohne Array-Typ variabler Länge erstreckt sich seine Lebensdauer vom Eintritt in den Block, dem es zugeordnet ist, bis die Ausführung dieses Blocks in irgendeiner Weise endet . (Durch das Eingeben eines eingeschlossenen Blocks oder das Aufrufen einer Funktion wird die Ausführung des aktuellen Blocks angehalten, aber nicht beendet.) Wenn der Block rekursiv eingegeben wird, wird jedes Mal eine neue Instanz des Objekts erstellt. Der Anfangswert des Objekts ist unbestimmt. Wenn für das Objekt eine Initialisierung angegeben ist, wird diese jedes Mal ausgeführt, wenn die Deklaration bei der Ausführung des Blocks erreicht wird. Andernfalls wird der Wert bei jedem Erreichen der Deklaration unbestimmt.

Ihre Frage ist nicht klar genug, um eindeutig beantwortet zu werden.

Einerseits führen Compiler normalerweise keine lokale Speicherzuweisung-Freigabe für verschachtelte Blockbereiche durch. Der lokale Speicher wird normalerweise nur einmal beim Funktionseingang zugewiesen und beim Funktionsende freigegeben.

Wenn andererseits die Lebensdauer eines lokalen Objekts endet, kann der von diesem Objekt belegte Speicher später für ein anderes lokales Objekt wiederverwendet werden. Zum Beispiel in diesem Code

void foo()
{
  {
    int d[100];
  }
  {
    double e[20];
  }
}

Beide Arrays belegen normalerweise denselben Speicherbereich, was bedeutet, dass die Gesamtmenge des von der Funktion benötigten lokalen Speichers foofür das größte von zwei Arrays erforderlich ist , nicht für beide gleichzeitig.

Ob letzterer dim Kontext Ihrer Frage weiterhin bis zum Ende der Funktion das Gedächtnis belegt, müssen Sie selbst entscheiden.

Es ist implementierungsabhängig. Ich habe ein kurzes Programm geschrieben, um zu testen, was gcc 4.3.4 macht, und es ordnet zu Beginn der Funktion den gesamten Stapelspeicher auf einmal zu. Sie können die von gcc erzeugte Assembly mit dem Flag -S untersuchen.

Nein, d [] befindet sich für den Rest der Routine nicht auf dem Stapel. Aber alloca () ist anders.

Bearbeiten: Kristopher Johnson (und Simon und Daniel) haben Recht , und meine erste Antwort war falsch . Mit gcc 4.3.4.on CYGWIN lautet der Code:

void foo(int[]);
void bar(void);
void foobar(int); 

void foobar(int flag) {
    if (flag) {
        int big[100000000];
        foo(big);
    }
    bar();
}

gibt:

_foobar:
    pushl   %ebp
    movl    %esp, %ebp
    movl    $400000008, %eax
    call    __alloca
    cmpl    $0, 8(%ebp)
    je      L2
    leal    -400000000(%ebp), %eax
    movl    %eax, (%esp)
    call    _foo
L2:
    call    _bar
    leave
    ret

Lebe und lerne! Und ein schneller Test scheint zu zeigen, dass AndreyT auch bei mehreren Zuordnungen korrekt ist.

Viel später hinzugefügt : Der obige Test zeigt, dass die gcc-Dokumentation nicht ganz richtig ist. Seit Jahren heißt es (Hervorhebung hinzugefügt):

"Der Speicherplatz für ein Array mit variabler Länge wird freigegeben , sobald der Gültigkeitsbereich des Arraynamens endet ."

Sie könnten. Sie könnten nicht. Die Antwort, die Sie meiner Meinung nach wirklich brauchen, lautet: Nehmen Sie niemals etwas an. Moderne Compiler machen alle Arten von Architektur und implementierungsspezifischer Magie. Schreiben Sie Ihren Code einfach und leserlich an Menschen und lassen Sie den Compiler die guten Dinge tun. Wenn Sie versuchen, um den Compiler herum zu programmieren, fragen Sie nach Problemen - und die Probleme, die Sie normalerweise in diesen Situationen bekommen, sind normalerweise schrecklich subtil und schwer zu diagnostizieren.

Ihre Variable dwird normalerweise nicht vom Stapel genommen. Geschweifte Klammern bezeichnen keinen Stapelrahmen. Andernfalls könnten Sie so etwas nicht tun:

char var = getch();
    {
        char next_var = var + 1;
        use_variable(next_char);
    }

Wenn geschweifte Klammern einen echten Stack-Push / Pop verursachen würden (wie es ein Funktionsaufruf tun würde), würde der obige Code nicht kompiliert werden, da der Code in den Klammern nicht auf die Variable zugreifen könnte var, die außerhalb der Klammern lebt (genau wie ein Unter-) Funktion kann nicht direkt auf Variablen in der aufrufenden Funktion zugreifen). Wir wissen, dass dies nicht der Fall ist.

Geschweifte Klammern werden einfach zum Scoping verwendet. Der Compiler behandelt jeden Zugriff auf die "innere" Variable von außerhalb der umschließenden Klammern als ungültig und verwendet diesen Speicher möglicherweise für etwas anderes (dies ist implementierungsabhängig). Es kann jedoch nicht vom Stapel entfernt werden, bis die umschließende Funktion zurückkehrt.

Update: Hier ist, was die C-Spezifikation zu sagen hat. In Bezug auf Objekte mit automatischer Speicherdauer (Abschnitt 6.4.2):

Bei einem Objekt ohne Array-Typ variabler Länge erstreckt sich seine Lebensdauer vom Eintrag in den Block, dem es zugeordnet ist, bis die Ausführung dieses Blocks ohnehin endet.

Der gleiche Abschnitt definiert den Begriff "Lebensdauer" als (Schwerpunkt Mine):

Die Lebensdauer eines Objekts ist der Teil der Programmausführung, während dessen der Speicher garantiert dafür reserviert ist. Ein Objekt existiert, hat eine konstante Adresse und behält seinen zuletzt gespeicherten Wert während seiner gesamten Lebensdauer bei. Wenn auf ein Objekt außerhalb seiner Lebensdauer verwiesen wird, ist das Verhalten undefiniert.

Das Schlüsselwort hier ist natürlich "garantiert". Sobald Sie den Bereich des inneren Satzes von geschweiften Klammern verlassen, ist die Lebensdauer des Arrays abgelaufen. Möglicherweise wird noch Speicher dafür zugewiesen (Ihr Compiler verwendet den Speicherplatz möglicherweise für etwas anderes), aber alle Versuche, auf das Array zuzugreifen, rufen undefiniertes Verhalten hervor und führen zu unvorhersehbaren Ergebnissen.

Die C-Spezifikation kennt keine Stapelrahmen. Es spricht nur das Verhalten des resultierenden Programms an und überlässt die Implementierungsdetails dem Compiler (schließlich würde die Implementierung auf einer stapellosen CPU ganz anders aussehen als auf einer CPU mit einem Hardware-Stapel). In der C-Spezifikation gibt es nichts, was vorschreibt, wo ein Stapelrahmen enden wird oder nicht. Die einzige wirkliche Möglichkeit zu wissen , ist , den Code auf Ihre speziellen Compiler / Plattform zu kompilieren und die resultierende Anordnung zu untersuchen. Die aktuellen Optimierungsoptionen Ihres Compilers werden wahrscheinlich auch hier eine Rolle spielen.

Wenn Sie sicherstellen möchten , dass die Anordnung dnicht mehr Speicher zu essen, während der Code ausgeführt wird , können Sie entweder den Code in geschweiften Klammern in eine separate Funktion umwandeln oder explizit mallocund freedem Speicher statt mit dynamischem Speicher.

Ich glaube, dass es außerhalb des Gültigkeitsbereichs liegt, aber erst dann vom Stapel genommen wird, wenn die Funktion zurückkehrt. Es nimmt also weiterhin Speicher auf dem Stapel ein, bis die Funktion abgeschlossen ist, ist jedoch stromabwärts der ersten schließenden geschweiften Klammer nicht zugänglich.

Es wurden bereits viele Informationen zu dem Standard gegeben, die darauf hinweisen, dass er tatsächlich implementierungsspezifisch ist.

Ein Experiment könnte also von Interesse sein. Wenn wir den folgenden Code versuchen:

#include <stdio.h>
int main() {
    int* x;
    int* y;
    {
        int a;
        x = &a;
        printf("%p\n", (void*) x);
    }
    {
        int b;
        y = &b;
        printf("%p\n", (void*) y);
    }
}

Mit gcc erhalten wir hier zweimal die gleiche Adresse: Coliro

Aber wenn wir den folgenden Code versuchen:

#include <stdio.h>
int main() {
    int* x;
    int* y;
    {
        int a;
        x = &a;
    }
    {
        int b;
        y = &b;
    }
    printf("%p\n", (void*) x);
    printf("%p\n", (void*) y);
}

Mit gcc erhalten wir hier zwei verschiedene Adressen: Coliro

Sie können sich also nicht sicher sein, was los ist.