Ist es gut, eine Variable innerhalb einer Schleife zu definieren? [geschlossen]

Mein Lehrer hat mir einmal gesagt, dass ich keine Variable innerhalb einer Schleife definieren soll , aber ich verstehe ehrlich gesagt immer noch nicht warum.

Was sind die Nachteile davon?

Könnte mir jemand das erklären?

Es ist kein Problem , eine Variable innerhalb einer Schleife zu definieren . In der Tat ist es eine gute Praxis, da Bezeichner auf den kleinstmöglichen Bereich beschränkt sein sollten.

Schlecht ist es , eine Variable innerhalb einer Schleife zuzuweisen, wenn Sie sie auch einmal zuweisen könnten, bevor die Schleife ausgeführt wird. Je nachdem, wie komplex die rechte Seite der Zuweisung ist, kann dies ziemlich teuer werden und sogar die Laufzeit der Schleife dominieren. Wenn Sie eine Schleife schreiben, die in allen Iterationen denselben berechneten Wert verwendet, sollten Sie sie unbedingt über der Schleife berechnen - das ist wichtiger als die Minimierung ihres Umfangs.

Zur Verdeutlichung: Solange compute()immer derselbe Wert zurückgegeben wird, ist dies

int value = compute();
while (something) {
    doSomething(value);
}

ist schlauer als das:

while (something) {
    int value = compute();
    doSomething(value);
}

Komplexe Typen haben nicht triviale Konstruktoren und Destruktoren.

Diese werden am Anfang und Ende des Schleifenkörpers aufgerufen (wenn er initialisiert wird und den Gültigkeitsbereich verlässt). Wenn die Initialisierung teuer ist und Speicherplatz benötigt, sollte dies vermieden werden.

Für Trivialtypen ist dies jedoch kein Problem. Die Zuweisung und Freigabe selbst addiert und subtrahiert lediglich einen Wert vom Stapelzeiger. (was optimiert wird)

Nun, sein Rat ist etwas zu einfach (das ist eine Untertreibung).
Das Folgen reicht von einer guten Idee über wen kümmert es und eine schlechte Idee bis hin zu unmöglich .

1. Sie sollten es befolgen, wenn die Wiederverwendung billiger ist als die Zerstörung der alten und die Erstellung einer neuen.

   #include <iostream>
   #include <string>
   
   int main() {
       std::string s; // Don't needlessly free the buffer
       while ((std::cin >> s))
           std::cout << s;
   }

2. Sie sollten es als eine Frage des Stils meiden, wenn es für die Leistung keine Rolle spielt.

   #include <stdio.h>
   #include <stdlib.h>
   int f(int, int);
   
   int main() {
       for (int i = 0; i < 100; ++i) {
           int x = rand(); // Declared here so you don't need to hunt it down.
           printf("%d => %d\n", x, f(x-1, x+i));
       }
   }

3. Sie sollten es wirklich meiden, wenn es schlechtere Leistung oder die falsche Semantik hat.

   #include <iostream>
   #include <string>
   std::string generate(int);
   
   int main() {
       for(int i = 0; i < 100; ++i) {
           std::string s = generate(i); // Using copy-ellision here
           std::cout << s;
       }
   }

4. Sie können es nicht befolgen, wenn der verwendete Typ weder das Vertauschen noch die Zuweisung von Verschiebungen oder Kopien zulässt.

   #include <iostream>
   #include <puzzle>
   
   int main() {
       for (int i = 0; i < 100; ++i) {
           Puzzle x(i); // Puzzle is an immutable class. For whatever reasons.
           std::cout << x;
       }
   }