Wie kann ich lokale Variable in einem anderen Bereich in C++ verwenden?

Question

Ich möchte auf eine lokale Variable der Hauptfunktion in einem anderen Bereich zugreifen.
Mein Ziel ist 20 in cout zu drucken.
Wie kann ich das tun?
Wie ist es in C++ möglich?

int var = 10; 

int main(int argc, char *argv[]) 
{ 
    int var = 20; // this var 
    { 
     int var = 40; 
     cout << ::var; // I want to print `var` variable in main scope. 
         // But this command print global variable. 
    } 

    return 0; 
} 

Answer 1

Es gibt keine Möglichkeit, dies zu erreichen. Die Sprache bietet keine Möglichkeit, zwischen dem ersten var in main aus dem zweiten var zu unterscheiden.

Wenn Sie jemals Produktionscode schreiben, verwenden Sie solche Variablen bitte nicht. Es wird zu fehlerhaftem Code führen. Sie werden verwirrt sein, welche Variable in einer bestimmten Codezeile enthalten ist.

Answer 2

Fall A

int var = 10; 
int main(int argc, char *argv[]) 
{ 
    int var = 20; // this var 
    { 
     int var = 40; 
     cout << ::var; // This will output 10 because you have used scope of operator that'll point to global variable in C++. 
    } 


    return 0; 
} 

Fall B

int var = 10; 
int main(int argc, char *argv[]) 
{ 
    int var = 20; // this var 
    { 
     int var = 40; 
     cout <<var; // This will output 40 because you are using local variable. 
    } 


    return 0; 
} 

CASE C

int var = 10; 
int main(int argc, char *argv[]) 
{ 
    int var = 20; // this var 
    { 
     int var = 40; 
    } 

    cout << var; // this will output 20 because using var that is declared in main() function. 

    return 0; 
} 

Answer 3

Sie können nicht auf eine Variable (in einigen Fällen extern kann verwendet werden, aber nicht in Ihrem Code) außerhalb ihres Geltungsbereichs zugreifen. Daher können Sie die Variable var (die im innersten Block deklariert ist) nicht außerhalb ihres Gültigkeitsbereichs verwenden. Zum Beispiel

int var = 10; 
int main(int argc, char *argv[]) 
{ 
    int var = 20; // this var 
    { 
     int var = 40; 
    } 

    cout << var; // this will access var declared first and prints 20 
    return 0; 
} 

Und vertrauen Sie mir, es gibt keine Notwendigkeit, Variablen auf diese Weise zu deklarieren und zu verwenden. Es wird zu fehlerhaftem Code führen. Denken Sie daran, wenn Sie GCC oder clang verwenden, verwenden Sie immer -Wshadow Compiler-Flag beim Kompilieren, da es eine Warnung anzeigt, wenn so etwas irgendwo im Code ausgeführt wird. Versuchen Sie, es in Ihre IDE oder Makefile aufzunehmen, wenn Sie Ihren Code nicht vom Terminal aus kompilieren.

Answer 4

In Bezug auf Ihren Beispielcode

int var = 10; 

int main(int argc, char *argv[]) 
{ 
    int var = 20; // this var 
    { 
     int var = 40; 
     cout << ::var; // I want to print `var` variable in main scope. 
         // But this command print global variable. 
    } 

    return 0; 
} 

& hellip; und das erklärte Ziel in dem Kommentar,

” Ich mag var Variable in Hauptbereich drucken

& hellip; Sie können das tun, wie folgt, einfach ein alias für sie und fügte hinzu:

int var = 10; 

int main() 
{ 
    int var = 20; // this var 
    { 
     auto& outer_var = var; 
     int var = 40; 
     cout << outer_var; 
    } 
} 

C++ bietet keinen Spielraum Bewältigungsmechanismus, die dies für Sie tun können. Wenn es einen solchen Mechanismus, z.B. relative Scope-Auflösung oder Funktionsnamen als Pseudo-Namespace-Namen, würde es vermutlich verwendet werden, und man würde dann zumindest einige Code sehen, die wegen der Verwendung desselben Namens für verschiedene Dinge innerhalb einer kurzen Strecke des Codes schwer zu verstehen wäre.Ein alternatives Sprachdesign ist wie C#, wo das Shadowing (wie das innere var Schatten der äußeren var) einfach verboten ist.

Ebenso bietet C++ keine Möglichkeit, zusätzliche Namen für den globalen Namespace bereitzustellen. Andere Namespaces können Alias ​​sein, aber nicht der globale Namespace, so dass man ziemlich sicher sein kann, dass der globale Namespace nicht über etwas wie etwa companyname::counter referenziert wird.

In C++ gibt es auch eine Einschränkung, welche Operatoren durch Namespace-Scope-Funktionen überladen werden können, wiederum um ein gewisses Maß an geistiger Gesundheit zu bieten, worauf man sich absolut verlassen kann. In Bezug auf diese letzte Begründung kenne ich das von Bjarne Stroustrup (dem Sprachschöpfer). In Bezug auf die Gründe für das Fehlen einer relativen Auflösung des Bereichs und das Fehlen von globalem Namensraum-Aliasing ist es nur eine qualifizierte Vermutung, dass es dasselbe ist, aber es liegt nahe. :)