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

13

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

¿Cuáles son las desventajas de eso?

¿Podría algún cuerpo explicarme eso?

    
pregunta user3260672 08.09.2015 - 16:32

3 respuestas

36

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 podría asignarlo una vez antes para que se ejecute el bucle. Dependiendo de la complejidad del lado derecho de la asignación, esto podría resultar bastante costoso e incluso podría dominar el tiempo de ejecución del bucle. Si escribe un bucle que utiliza el mismo valor computado en todas las iteraciones, definitivamente debe calcularlo arriba del bucle, eso es más importante que minimizar su alcance.

Para aclarar: siempre que 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);
}
    
respondido por el Kilian Foth 08.09.2015 - 16:42
10

Los tipos complejos tienen constructores y destructores no triviales.

Se llamará a aquellos al principio y al final del bucle (ya que se inicializa y queda fuera del alcance). Si la inicialización es costosa, ya que necesita asignar algo de memoria, debería evitarse.

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

    
respondido por el ratchet freak 08.09.2015 - 16:45
5

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

  1. Deberías seguirlo cada vez que reutilizar sea más barato que destruir lo antiguo 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 debería evitarlo cuando tenga un rendimiento peor o la semántica incorrecta.

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

    #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;
        }
    }
    
respondido por el Deduplicator 08.09.2015 - 21:34

Lea otras preguntas en las etiquetas