È utile definire una variabile all'interno di un ciclo? [chiuso]

Il mio istruttore una volta mi disse che non avrei dovuto definire una variabile all'interno di un ciclo , ma onestamente non capisco ancora il perché.

Quali sono gli svantaggi di questo?

Qualcuno potrebbe spiegarmelo?

Non è un problema da definire una variabile all'interno di un ciclo. In effetti, è una buona pratica, poiché gli identificatori dovrebbero essere limitati al più piccolo ambito possibile.

La cosa brutta è assegnare una variabile all'interno di un ciclo se potessi anche assegnarla una volta prima che il ciclo venga eseguito. A seconda della complessità della parte destra del compito, questo potrebbe diventare piuttosto costoso e potrebbe persino dominare il tempo di esecuzione del loop. Se scrivi un ciclo che utilizza lo stesso valore calcolato in tutte le iterazioni, dovresti sicuramente calcolarlo sopra il ciclo, che è più importante che ridurne al minimo l'ambito.

Per chiarire: purché compute()restituisca sempre lo stesso valore, questo

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

è più intelligente di questo:

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

I tipi complessi hanno costruttori e distruttori non banali.

Verranno chiamati all'inizio e alla fine del corpo del loop (poiché è inizializzato e non rientra nell'ambito). Se l'inizializzazione è costosa come se fosse necessario allocare un po 'di memoria, questo dovrebbe essere evitato.

Tuttavia, per tipi banali non è un problema. L'allocazione e la deallocazione sono solo l'aggiunta e la sottrazione di un valore dal puntatore dello stack. (che verrà ottimizzato)

Bene, il suo consiglio è leggermente troppo semplice (è un eufemismo).
Dopo si va tutta la strada da una buona idea su chi se ne frega e cattiva idea per impossibile .

1. Dovresti seguirlo ogni volta che riutilizzare è più economico che distruggere il vecchio e crearne uno nuovo.

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

2. Dovresti evitarlo come una questione di stile quando non importa per le prestazioni.

   #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. Dovresti davvero evitarlo quando ha prestazioni peggiori o semantica errata.

   #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. Non è possibile seguirlo quando il tipo utilizzato non consente né lo scambio, né l'assegnazione di spostamenti né l'assegnazione di copie.

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