Sind Stack-Frames mit Scope zugeordnet und freigegeben?

Question

Im Anschluss an eine previous question here Ich habe die Ausgabe von der VS2015-Code-Analyse und sehen Sie eine Warnung für hohe Stack-Nutzung in einer Funktion, die wie folgt vereinfacht werden kann;

class base 
{ 
public: 
    virtual void Process(); 
    Buffer[10000]; 
}; 

class derived1 : public base 
{ 
public: 
    void Process(); 
} 

class derived2 : public base 
{ 
public: 
    void Process(); 
} 

void MyFunc(int x) 
{ 
    switch(x) 
    { 
    case 0: 
    { 
     derived1 x; 
     x.Process(); 
    } break; 
    case 1: 
    { 
     derived2 y; 
     y.Process(); 
    } break; 
    } 
} 

Die Analyse warnt mich, dass ich in MyFunc 20.000 Bytes Stack bin mit. Ist dies der Fall, da alle Stack-Variablen beim Funktionseingang zugewiesen und beim Funktionsexit nicht zugewiesen werden, statt dass sie mit Scope konstruiert und zerstört werden? Nur neugierig (aber nicht so neugierig genug, um durch die Assembly-Ausgabe zu waten;)) Eine related question hier gibt mir nicht die richtige Antwort, die ich suche.

Answer 1

Die Zuordnung der Stack-Frames liegt im Ermessen des Compilers. Die meisten Compiler versuchen nicht, lokale Bereiche mit großen Variablen zu isolieren, aber die meisten Compiler bieten eine Einrichtung wie alloca oder C99-VLAs, die einen vorhandenen Stapelrahmen dynamisch erweitern. Es ist also unwahrscheinlich, dass architektonische Fragen im Spiel sind. es ist nur eine Frage der Details der Implementierung.

können Sie lokale Bereiche in Lambda-Ausdrücke einschließen, den Compiler zu ermutigen, eine solche Isolation zu bieten:

switch(x) 
    { 
    case 0: 
    []{ 
     derived1 x; 
     x.Process(); 
    }(); break; 

    case 1: 
    []{ 
     derived2 y; 
     y.Process(); 
    }(); break; 
    } 

Noch ist nichts garantiert.

Sie können den Online-Compiler godbolt.org verwenden, um Maschinencode-Disassemblierung für solche Beispiele anzuzeigen. Es sieht so aus, als ob dieser Trick auf GCC funktioniert, aber auf Clang funktioniert es nur mit der Optimierung -O1 oder weniger, und auf Intels Compiler funktioniert es nur mit -O0.