Puoi dichiarare più variabili in un per loop in c++?
int i = 0;
int j = 0;
int k = 0;
Queste sono tre dichiarazioni che possono essere scritte in una dichiarazione, come:
int i = 0, j = 0, k = 0;
C'è un tipo di dati; Le espressioni sono separate dalle virgole. Una dichiarazione termina con un punto e virgola. Variabili multiple sono state dichiarate qui in una dichiarazione.
Ora, considera le seguenti dichiarazioni incrementali:
int i ++;
int j ++;
int k ++;
Queste tre affermazioni possono essere sostituite da una dichiarazione, come segue:
int i ++, j ++, k ++;
Qui, ci sono tre espressioni in una dichiarazione per un tipo di dati.
Considera anche le seguenti tre dichiarazioni condizionali:
io < 10;
J < 10;
K < 10;
Queste tre dichiarazioni, possono essere sostituite da una dichiarazione, come segue:
io < 10 && j < 10 && k < 10;
Qui, tre affermazioni sono state combinate in un'espressione di una forma speciale. Queste espressioni non sono separate dalle virgole come nei casi di cui sopra, ma sono combinate con il logico e.
Questo articolo spiega come più variabili possono essere dichiarate e utilizzate, in un circuito, con corrispondenze regolari. Per illustrazioni vengono utilizzati esempi molto semplici per illustrazioni.
Contenuto dell'articolo
- Per loop unidimensionale
- Per loop bidimensionale
- Per loop tridimensionale
- Possibile vantaggio
- Conclusione
Per loop unidimensionale
While-loop
Un liop while per visualizzare numeri da zero a 9, è come nel seguente programma:
#includere
Utilizzo dello spazio dei nomi std;
int main ()
int i = 0;
mentre io < 10)
cout << i << endl;
I ++;
restituzione 0;
La prima riga del programma include la libreria iostream per l'oggetto Cout. La riga successiva nel programma è una dichiarazione. Garantisce che qualsiasi nome utilizzato provenga dalla libreria standard C ++ se non diversamente indicato.
Nella funzione principale (), esiste l'istruzione di inizializzazione, del numero intero, i = 0. Quindi c'è il while-loop, che tiene conto dell'istruzione di inizializzazione. La condizione di tempo è (io < 10), and as long as i is less than 10 (never equal to 10), the cout iostream object in the body of the while-loop displays the value of i. The next statement in the while-loop increments i (adds 1 to the value of i).
L'output è il seguente ma visualizzato verticalmente:
0 1 2 3 4 5 6 7 8 9
Per loop unidimensionale
Il codice nella funzione principale () sopra, è riprodotto, nel seguente programma, come per loop:
#includere
Utilizzo dello spazio dei nomi std;
int main ()
per (int i = 0; i < 10; i++)
cout << i << endl;
restituzione 0;
L'output è uguale al caso sopra. L'istruzione di inizializzazione per il codice sopra è ora la prima affermazione tra le parentesi del per loop, seguita da un punto e virgola. La condizione di tempo per il codice sopra è ora la seconda affermazione tra le parentesi del per loop, seguita da un punto e virgola. La dichiarazione di incremento nel corpo del loop while, per il codice precedente, è ora la terza affermazione tra le parentesi del per loop per loop. Non è seguito da un punto e virgola perché è l'ultima affermazione tra parentesi. L'unica istruzione nel per loop visualizza il valore di i.
Per loop bidimensionale
Nidificato per loop
Il per il circuito monodimensionale sopra mostra una colonna, in cui ogni cella ha un numero, il valore di i. Un while-loop, nidificato in un altro circuito while, mostrava una tabella, in cui ogni cella avrebbe un numero (il valore di J in quella posizione). Il seguente programma illustra questo:
#includere
Utilizzo dello spazio dei nomi std;
int main ()
int i = 0;
mentre io < 5)
int j = 0;
mentre (j < 5)
cout << j << ";
J ++;
cout << endl;
I ++;
restituzione 0;
L'output è:
0 1 2 3 4
0 1 2 3 4
0 1 2 3 4
0 1 2 3 4
0 1 2 3 4
La variabile i determina le righe. La variabile J determina le colonne. I valori massimi per i e j sono ciascuno 4 in questo codice. Nessun valore di I è stampato. Per ogni valore di J, il valore di J è stampato in orizzontale. J è incrementato per stampare il valore successivo in orizzontale per ogni riga.
Esistono due dichiarazioni di inizializzazione: una per i e una per j, entrambe inizializzate a zero. La dichiarazione di inizializzazione per J è all'interno del ciclo esterno. In questo modo, J viene renizializzato per ogni riga (ogni linea orizzontale). In questo modo, J può produrre numeri da 0 a 4 per ogni riga. Il valore di I non è mai stampato; indica solo il numero di riga. Sono incrementato all'esterno e sotto il ciclo nidificato. Sono incrementato ai fini della riga successiva.
Nidificato per loop
Il seguente per loop nidificato produce lo stesso risultato (tabella) di quanto sopra nidificato while loop:
#includere
Utilizzo dello spazio dei nomi std;
int main ()
per (int i = 0; i < 5; i++)
per (int j = 0; j < 5; j++)
cout << j << ";
cout << endl;
restituzione 0;
Le parentesi di ciascuna per loop hanno una propria dichiarazione di inizializzazione, una propria dichiarazione di condizione e una propria dichiarazione di incremento.
Uno per low while
L'output della tabella sopra può essere prodotta da un while-loop, con un'istruzione di inizializzazione e un'affermazione della condizione. Tuttavia, il riassegnazione da zero a J e l'incremento di I deve verificarsi in una costruzione IF. Il seguente codice illustra questo:
#includere
Utilizzo dello spazio dei nomi std;
int main ()
int i = 0, j = 0;
mentre io < 5 && j <5)
cout << j << ";
J ++;
if (j == 5)
cout << endl;
j = 0;
I ++;
restituzione 0;
L'output è la stessa tabella di quella sopra.
Uno per loop
L'output della tabella sopra può essere prodotto da un per loop, con un'istruzione di inizializzazione e una dichiarazione di condizione. Tuttavia, il riassegnazione da zero a J e l'incremento di I deve verificarsi in una costruzione IF. Il seguente programma illustra questo:
#includere
Utilizzo dello spazio dei nomi std;
int main ()
per (int i = 0, j = 0; i < 5 && j <5; j++)
cout << j << ";
if (j == 4)
cout << endl;
j = -1;
I ++;
restituzione 0;
L'output è la stessa tabella di quella sopra. Tuttavia, qui, poiché J è incrementato alla fine del ciclo, tra le parentesi, la condizione if è (j == 4) e J è riassegnato, -1 per ogni riga.
Ciò che è spaziale qui è che due variabili sono state dichiarate in un loop per loop. E così, più variabili possono essere dichiarate in un circuito.
Leading Diagonale Indirizzamento
In una tabella quadrata, la diagonale principale è la diagonale dall'estremità in alto a sinistra all'estremità inferiore a destra. Il seguente programma mostra le coordinate della diagonale principale della tabella sopra:
#includere
Utilizzo dello spazio dei nomi std;
int main ()
per (int i = 0, j = 0; i < 5 && j <5; i++,j++)
cout << i << ',' << j << ";
cout << endl;
restituzione 0;
L'output è:
0,0 1,1 2,2 3,3 4,4
Si noti che nel programma, due variabili sono state dichiarate nelle parentesi del per loop; La condizione ha le due variabili, relative al logico e; e l'istruzione di incremento ha le due variabili, ciascuna incrementata aggiungendo una. In questa condizione, l'unica affermazione nel corpo del per loop stampica le coordinate della diagonale principale.
Per loop tridimensionale
Può essere ingombrante stampare tutti i valori delle celle di un cubo. Il seguente programma stampa le coordinate della diagonale principale di un cubo:
#includere
Utilizzo dello spazio dei nomi std;
int main ()
per (int i = 0, j = 0, k = 0; i<5&&j<5&&k<5; i++,j++,k++)
cout << i << ',' << j << ',' << k << ";
cout << endl;
restituzione 0;
L'output è:
0,0,0 1,1,1 2,2,2 3,3,3 4,4,4
Si noti che l'istruzione di inizializzazione ha tre variabili; L'affermazione della condizione ha le tre variabili e l'istruzione incremento ha le tre variabili. C'è solo una dichiarazione nel corpo del circuito.
Possibile vantaggio
Considera un singolo per loop per visualizzare tutti i valori delle celle di una tabella quadrata:
Avere le due variabili nell'istruzione di inizializzazione e nella condizione non porta alcun vantaggio nella velocità, rispetto alla situazione in cui un ciclo è nidificato.
Tuttavia, se si accede solo ai valori selezionati nella tabella, quindi avere le due variabili, nell'istruzione di inizializzazione, nell'affermazione delle condizioni e nella dichiarazione di incremento, porterebbe un vantaggio nella velocità; Nel senso che non saranno accessibili tutti i valori, prima di eliminarne molti di essi. Nel seguente programma, ogni altra coppia di coordinate, nella diagonale principale, è stampata:
#includere
Utilizzo dello spazio dei nomi std;
int main ()
per (int i = 0, j = 0; i < 10 && j <10; i+=2,j+=2)
cout << i << ',' << j << ";
cout << endl;
restituzione 0;
L'output è:
0,0 2,2 4,4 6,6 8,8
C'è ancora solo una dichiarazione nel per loop. Ottenere un vantaggio nella velocità, in questo modo, prevede l'inclusione della logica selettiva aggiuntiva nell'istruzione condizione e/o nell'istruzione incremento. Le espressioni di inizializzazione nell'istruzione di inizializzazione potrebbero non essere inizializzate a zero.
Nel codice sopra, l'istruzione incremento è:
i+= 2, j+= 2
che significa,
i = i+2, j = j+2;
Conclusione
Sì, posso dichiarare più variabili in un circuito. E anche tu puoi dichiarare più variabili, in un per loop, come segue: basta separare le variabili multiple nell'istruzione di inizializzazione con le virgole. Non dimenticare di terminare la dichiarazione di inizializzazione completa con un punto e virgola. Se l'accesso degli elementi della struttura deve essere selettivo, è possibile utilizzare anche queste variabili, nella condizione e/o nelle dichiarazioni di incremento, tra le parentesi del per loop, possibilmente con una logica aggiuntiva.