I loop dovrebbero essere letti verso l'interno o l'esterno? [chiuso]

Non puoi veramente leggere i loop verso l'interno o l'esterno, è un po 'più complesso di così.

I loop iniziano con il ciclo esterno, ma per ogni iterazione in quel ciclo, il ciclo interno passa attraverso un ciclo completo.

Se dovessi stampare i contatori all'interno del ciclo interno, vedresti:

 i   j
--- ---
 0   0
 0   1
 0   2
 0   3
 1   0
 1   1
 1   2
 1   3
 2   0
 2   1
 2   2
 2   3

Questa è una domanda difficile a cui rispondere. LEGGEREi i loop dall'alto verso il basso. Immagino quindi che tu stia facendo riferimento all'ordine in cui il codice viene eseguito. Quando vedi una struttura di loop, come quella del tuo codice, il ciclo più esterno è la prima cosa che viene eseguita.

 for (i = 0; i < 3; i++) //This indicates that whatever is in between the braces that 
                         //follow will be run 3 times.
  {
     for (j = 0; j < 4; j++)
     {
       cout << arr2d[i][j] << "\t";
     }    
   cout << endl;
  }

La prossima riga di codice è ciò che viene eseguito. Nel tuo caso, questo è un altro ciclo. Risciacqua e ripeti.

 for (i = 0; i < 3; i++)  
  {
     for (j = 0; j < 4; j++) //This loop will execute 4 times for each iteration 
                             //of the outer loop
     {
       cout << arr2d[i][j] << "\t";   //Therefore, this statement is executed 
                                      //12 times in total
     }    
   cout << endl; //and this one only 3, as it is outside of the inner loop.
  }

Quindi come leggerli? Dall'alto verso il basso. Traccia le tue parentesi e ricorda che la prima riga di codice che avviene dopo le parentesi graffe sarà quella da eseguire per prima. Per dirla con le parole, "outward-in", assicurati di non pensare che i loop abbiano una precedenza più alta rispetto ad altri codici . Se dovessimo inserire un cout tra il primo e il secondo ciclo, il ciclo esterno inizierebbe l'esecuzione, quindi il cout e infine il ciclo interno (e il suo contenuto) seguiti da eventuali istruzioni successive.

Penso che tu debba pensare in termini di elementi costitutivi, piuttosto che leggere dentro o fuori. Prima di tutto aggiungi la parentesi graffa come segue:

for (i = 0; i < 3; i++)
 {
    for (j = 0; j < 4; j++)
    {
        cout << arr2d[i][j] << "\t";
    }    
    cout << endl;
  }

Il tuo primo blocco è questo:

cout << arr2d[i][j] << "\t";

È ciò che verrà eseguito più e più volte dalle istruzioni for.

Il prossimo blocco è questo:

for (j = 0; j < 4; j++) { <something here> }

Questa è la funzione di loop. E l'esterno per blocco (in alto) è simile. I due blocchi insieme possono anche essere scritti in questo modo senza le parentesi poiché è solo una dichiarazione su cui è necessario eseguire il ciclo, che ti dà un altro modo di vederla:

for (j = 0; j < 4; j++) cout << arr2d[i][j] << "\t";

In passato i linguaggi di programmazione come BASIC non erano strutturati. Un programma consisteva in linee numerate di codice e si poteva saltare da qualsiasi linea a qualsiasi altra linea usando un'istruzione GOTO. Ciò ha reso molto difficile la lettura di un programma poiché non è stato possibile capirlo leggendo le righe dall'alto verso il basso. Era anche molto difficile mantenere un tale codice.

Quindi è stata introdotta la cosiddetta Programmazione strutturata . L'idea alla base è che il programma è costituito da blocchi che appaiono in un ordine top-down rigoroso. I blocchi possono anche essere annidati. Un ciclo, ad esempio, è un blocco con blocchi nidificati che possono essere eseguiti ripetutamente. Questi blocchi nidificati vengono nuovamente eseguiti in un ordine top-down rigoroso.

C ++ è un linguaggio di programmazione strutturato. (Esiste un'istruzione goto quindi, che dovrebbe essere utilizzata solo in casi eccezionali.) Pertanto è possibile leggere una routine C ++ in un ordine top-down.

I cicli for nidificati sono solo un caso speciale di un blocco di loop che contiene nuovamente un blocco di loop annidato. Il codice è costituito da un blocco di loop esterno con due blocchi nidificati che possono essere eseguiti ripetutamente. Succede che il primo dei due blocchi annidati è di nuovo un blocco di loop. Il secondo blocco annidato verrà eseguito una volta terminato il primo, come con qualsiasi altro blocco (o istruzione) non ciclico. Una volta eseguito l'ultimo blocco nidificato, il controllo viene passato al blocco del ciclo esterno che a sua volta "decide" se i blocchi nidificati verranno eseguiti nuovamente.