Deklarieren von Variablen in Schleifen, gute oder schlechte Praxis?

Question

Frage #1: Ist die Deklaration einer Variablen innerhalb einer Schleife eine gute oder schlechte Praxis?

Ich habe die anderen Threads darüber gelesen, ob es ein Leistungsproblem gibt oder nicht (die meisten sagten nein), und dass man Variablen immer so nah wie möglich an dem Ort deklarieren sollte, an dem sie verwendet werden. Was ich mich frage, ist, ob dies vermieden werden sollte, oder wenn es tatsächlich bevorzugt wird.

Beispiel:

for(int counter = 0; counter <= 10; counter++)
{
   string someString = "testing";

   cout << someString;
}

Frage #2: Erkennen die meisten Compiler, dass die Variable bereits deklariert wurde und überspringen diesen Teil einfach, oder wird jedes Mal ein Platz im Speicher für die Variable geschaffen?

Answer 1

Es gab einmal eine Zeit (vor C++98), da brach das Folgende ab:

{
    for (int i=0; i<.; ++i) {std::string foo;}
    for (int i=0; i<.; ++i) {std::string foo;}
}

mit der Warnung, dass i bereits deklariert wurde (foo war in Ordnung, da es innerhalb der {} skaliert ist). Dies ist wahrscheinlich der Grund, warum die Leute zuerst argumentieren würden, dass es schlecht ist. Es ist aber schon lange nicht mehr wahr.

Wenn Sie noch so einen alten Compiler unterstützen müssen (einige Leute sind auf Borland), dann ist die Antwort ja, ein Fall könnte gemacht werden, um die i aus der Schleife zu setzen, weil nicht so macht es macht es "härter" für Menschen, mehrere Schleifen in mit der gleichen Variable zu setzen, obwohl ehrlich gesagt der Compiler noch fehlschlagen wird, was alles, was Sie wollen, wenn es ein Problem sein wird.

Wenn Sie einen so alten Compiler nicht mehr unterstützen müssen, sollten Sie die Variablen so klein wie möglich halten, damit Sie nicht nur den Speicherverbrauch minimieren, sondern auch das Verständnis des Projekts erleichtern. Das ist ein bisschen so, als würde man fragen, warum man nicht alle Variablen global hat. Es gilt das gleiche Argument, nur dass sich die Geltungsbereiche ein wenig ändern.

Answer 2

Es ist eine sehr gute Praxis, wie alle oben Antwort bieten sehr gute theoretische Aspekt der Frage lassen Sie mich einen Einblick in den Code geben, war ich versuchen, DFS über GEEKSFORGEEKS zu lösen, stoße ich die Optimierung Problem...... Wenn Sie versuchen, den Code zu lösen, indem Sie die ganze Zahl außerhalb der Schleife deklarieren, erhalten Sie einen Optimierungsfehler.

stack<int> st;
st.push(s);
cout<<s<<" ";
vis[s]=1;
int flag=0;
int top=0;
while(!st.empty()){
    top = st.top();
    for(int i=0;i<g[top].size();i++){
        if(vis[g[top][i]] != 1){
            st.push(g[top][i]);
            cout<<g[top][i]<<" ";
            vis[g[top][i]]=1;
            flag=1;
            break;
        }
    }
    if(!flag){
        st.pop();
    }
}

Setzen Sie nun ganze Zahlen in die Schleife, dann erhalten Sie die richtige Antwort...

stack<int> st;
st.push(s);
cout<<s<<" ";
vis[s]=1;
// int flag=0;
// int top=0;
while(!st.empty()){
    int top = st.top();
    int flag = 0;
    for(int i=0;i<g[top].size();i++){
        if(vis[g[top][i]] != 1){
            st.push(g[top][i]);
            cout<<g[top][i]<<" ";
            vis[g[top][i]]=1;
            flag=1;
            break;
        }
    }
    if(!flag){
        st.pop();
    }
}

Dies spiegelt vollständig wider, was Sir @justin im 2. Kommentar gesagt hat.... Versuchen Sie dies hier https://practice.geeksforgeeks.org/problems/depth-first-traversal-for-a-graph/1 . probieren Sie es einfach aus.... Sie werden es schaffen.hoffe das hilft.

Answer 3

Kapitel 4.8 Blockstruktur in K&R's Die Programmiersprache C 2.Ed. :

Eine automatische Variable, deklariert und initialisiert in einer Block deklariert und initialisiert wurde, wird jedes Mal initialisiert, wenn der Block betreten wird.

Vielleicht habe ich die entsprechende Beschreibung im Buch übersehen:

Eine automatische Variable, deklariert und initialisiert in einer Block deklariert und initialisiert wird, wird nur einmal zugewiesen, bevor der Block eingegeben wird.

Ein einfacher Test kann jedoch beweisen, dass diese Annahme zutrifft:

 #include <stdio.h>                                                                                                    

 int main(int argc, char *argv[]) {                                                                                    
     for (int i = 0; i < 2; i++) {                                                                                     
         for (int j = 0; j < 2; j++) {                                                                                 
             int k;                                                                                                    
             printf("%p\n", &k);                                                                                       
         }                                                                                                             
     }                                                                                                                 
     return 0;                                                                                                         
 }