¿Es bueno definir una variable dentro de un bucle? [cerrado]

Mi instructor una vez me dijo que no debería definir una variable dentro de un ciclo , pero honestamente todavía no entiendo por qué.

¿Cuáles son las desventajas de eso?

¿Podría alguien explicarme eso?

No es un problema definir una variable dentro de un bucle. De hecho, es una buena práctica, ya que los identificadores deben limitarse al alcance más pequeño posible.

Lo que es malo es asignar una variable dentro de un bucle si también podría asignarla una vez antes de que se ejecute el bucle. Dependiendo de cuán complejo sea el lado derecho de la tarea, esto podría volverse bastante costoso e incluso podría dominar el tiempo de ejecución del ciclo. Si escribe un bucle que usa el mismo valor calculado en todas las iteraciones, definitivamente debe calcularlo por encima del bucle; eso es más importante que minimizar su alcance.

Para aclarar: siempre y cuando compute()siempre devuelva el mismo valor, este

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

es más inteligente que esto:

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

Los tipos complejos tienen constructores y destructores no triviales.

Esos serán llamados al comienzo y al final del cuerpo del bucle (ya que se inicializa y queda fuera de alcance). Si la inicialización es costosa, ya que necesita asignar algo de memoria, entonces debe evitarse.

Sin embargo, para los tipos triviales no hay problema. La asignación y la desasignación en sí mismas solo suman y restan un valor del puntero de la pila. (que se optimizará)

Bueno, su consejo es un poco demasiado simple (eso es un eufemismo).
Seguirlo va desde una buena idea sobre a quién le importa y una mala idea hasta lo imposible .

1. Debe seguirlo siempre que reutilizarlo sea más barato que destruir lo viejo y crear uno nuevo.

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

2. Debes evitarlo como una cuestión de estilo cuando no importa para el rendimiento.

   #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. Usted realmente debe rechazar cuando se selecciona con peor rendimiento o la semántica equivocadas.

   #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. No puede seguirlo cuando el tipo utilizado no permite ni el intercambio, ni la asignación de movimiento ni la asignación de copia.

   #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;
       }
   }