Pouvez-vous déclarer plusieurs variables dans une boucle pour C++?
int i = 0;
int j = 0;
int k = 0;
Ce sont trois déclarations qui peuvent être écrites dans une déclaration, comme:
int i = 0, j = 0, k = 0;
Il existe un type de données; Les expressions sont séparées par des virgules. Une déclaration se termine par un point-virgule. Plusieurs variables ont été déclarées ici dans une déclaration.
Maintenant, considérez les déclarations incrémentielles suivantes:
int i ++;
int j ++;
int k ++;
Ces trois déclarations peuvent être remplacées par une déclaration, comme suit:
int i ++, j ++, k ++;
Ici, il y a trois expressions dans une déclaration pour un type de données.
Considérez également les trois déclarations conditionnelles suivantes:
je < 10;
J < 10;
k < 10;
Ces trois déclarations peuvent être remplacées par une déclaration, comme suit:
je < 10 && j < 10 && k < 10;
Ici, trois déclarations ont été combinées en une seule expression d'une forme spéciale. Ces expressions ne sont pas séparées par des virgules comme dans les cas ci-dessus, mais ils sont combinés avec la logique et.
Cet article explique comment plusieurs variables peuvent être déclarées et utilisées, dans une boucle forte, avec des correspondances régulières. Des exemples très simples sont utilisés pour les illustrations.
Contenu de l'article
- Boucle unidimensionnelle
- Boucle bidimensionnelle
- Boucle tridimensionnelle
- Avantage possible
- Conclusion
Boucle unidimensionnelle
en boucle
Une boucle pour afficher les numéros de zéro à 9, est comme dans le programme suivant:
#inclure
Utilisation de Namespace Std;
int main()
int i = 0;
alors que je < 10)
couter << i << endl;
i ++;
retour 0;
La première ligne du programme comprend la bibliothèque iOStream pour l'objet COUT. La ligne suivante du programme est une déclaration. Il garantit que tout nom utilisé provient de la bibliothèque standard C ++, sauf indication contraire.
Dans la fonction principale (), il y a l'instruction d'initialisation, de l'entier, i = 0. Ensuite, il y a la boucle while, qui prend en compte l'instruction d'initialisation. La condition de ce qui est (je < 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).
La sortie est la suivante mais affichée verticalement:
0 1 2 3 4 5 6 7 8 9
Boucle unidimensionnelle
Le code dans la fonction principale () ci-dessus, est reproduit, dans le programme suivant, en tant que boucle:
#inclure
Utilisation de Namespace Std;
int main()
pour (int i = 0; i < 10; i++)
couter << i << endl;
retour 0;
La sortie est la même que dans le cas ci-dessus. L'instruction d'initialisation du code ci-dessus est désormais la première déclaration des parenthèses de la boucle pour. La condition de ce qui est le code ci-dessus est désormais la deuxième déclaration des parenthèses de la boucle pour. L'instruction d'incrément dans le corps de la boucle while, pour le code précédent, est désormais la troisième déclaration des parenthèses de la boucle pour. Il n'est pas suivi d'un point-virgule car c'est la dernière déclaration des parenthèses. La seule instruction de la boucle for-oper affiche la valeur de i.
Boucle bidimensionnelle
Imbriqué
La boucle à forte dimension ci-dessus affiche une colonne, où chaque cellule a un nombre, la valeur de i. Une boucle de temps, imbriquée dans une autre en boucle, affichait une table, où chaque cellule aurait un nombre (la valeur de J à cette position). Le programme suivant illustre ceci:
#inclure
Utilisation de Namespace Std;
int main()
int i = 0;
alors que je < 5)
int j = 0;
tandis que (J < 5)
couter << j << ";
j ++;
couter << endl;
i ++;
retour 0;
La sortie est:
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 variable I détermine les lignes. La variable J détermine les colonnes. Les valeurs maximales pour I et J sont chacune 4 dans ce code. Aucune valeur de i n'est imprimée. Pour chaque valeur de J, la valeur de J est imprimée horizontalement. J est incrémenté pour imprimer la valeur suivante horizontalement pour chaque ligne.
Il y a deux instructions d'initialisation: une pour I et une pour J, toutes deux initialisées à zéro. L'instruction d'initialisation pour J est dans la boucle extérieure. De cette façon, J est réinitialisé pour chaque ligne (chaque ligne horizontale). De cette façon, j peut produire des nombres de 0 à 4 pour chaque ligne. La valeur de i n'est jamais imprimée; il indique uniquement le numéro de ligne. I est incrémenté à l'extérieur et en dessous de la boucle imbriquée. I est incrémenté aux fins de la ligne suivante.
Boucle imbriquée
La boucle imbriquée suivante produit le même résultat (tableau) que la boucle imbriquée ci-dessus:
#inclure
Utilisation de Namespace Std;
int main()
pour (int i = 0; i < 5; i++)
pour (int j = 0; j < 5; j++)
couter << j << ";
couter << endl;
retour 0;
Les parenthèses de chaque boucle ont sa propre déclaration d'initialisation, sa propre déclaration de condition et sa propre déclaration d'incrément.
Une boucle
La sortie de la table ci-dessus peut être produite par une boucle while, avec une instruction d'initialisation et une instruction de condition. Cependant, la réaffectation de zéro à j et l'incrément de i doivent se produire dans une contrainte IF. Le code suivant illustre ceci:
#inclure
Utilisation de Namespace Std;
int main()
int i = 0, j = 0;
alors que je < 5 && j <5)
couter << j << ";
j ++;
if (j == 5)
couter << endl;
j = 0;
i ++;
retour 0;
La sortie est le même tableau que celui ci-dessus.
Une boucle pour
La sortie du tableau ci-dessus peut être produite par une boucle pour une instruction d'initialisation et une instruction de condition. Cependant, la réaffectation de zéro à j et l'incrément de i doivent se produire dans une contrainte IF. Le programme suivant illustre ceci:
#inclure
Utilisation de Namespace Std;
int main()
pour (int i = 0, j = 0; i < 5 && j <5; j++)
couter << j << ";
if (j == 4)
couter << endl;
j = -1;
i ++;
retour 0;
La sortie est le même tableau que celui ci-dessus. Cependant, ici, puisque J est incrémenté à la fin de la boucle, entre parenthèses, la condition IF est (j == 4), et J est réaffecté, -1 pour chaque ligne.
Ce qui est spacial ici, c'est que deux variables ont été déclarées dans une boucle pour. Et donc, plusieurs variables peuvent être déclarées dans une boucle pour.
Adresse diagonale principale
Dans une table carrée, la diagonale principale est la diagonale de l'extrémité supérieure gauche à l'extrémité inférieure droite. Le programme suivant affiche les coordonnées de la diagonale principale du tableau ci-dessus:
#inclure
Utilisation de Namespace Std;
int main()
pour (int i = 0, j = 0; i < 5 && j <5; i++,j++)
couter << i << ',' << j << ";
couter << endl;
retour 0;
La sortie est:
0,0 1,1 2,2 3,3 4,4
Notez que dans le programme, deux variables ont été déclarées entre parenthèses de la boucle pour La condition a les deux variables, liées par la logique et; et l'instruction d'incrément a les deux variables, chacune incrémentée en ajoutant une. Dans cette condition, la seule déclaration dans le corps de la boucle pour imprimer les coordonnées de la diagonale principale.
Boucle tridimensionnelle
Il peut être lourd d'imprimer toutes les valeurs des cellules d'un cube. Le programme suivant imprime simplement les coordonnées de la diagonale principale d'un cube:
#inclure
Utilisation de Namespace Std;
int main()
pour (int i = 0, j = 0, k = 0; i<5&&j<5&&k<5; i++,j++,k++)
couter << i << ',' << j << ',' << k << ";
couter << endl;
retour 0;
La sortie est:
0,0,0 1,1,1 2,2,2 3,3,3 4,4,4
Notez que l'instruction d'initialisation a trois variables; L'énoncé de condition a les trois variables, et l'instruction Incrément a les trois variables. Il n'y a qu'une seule déclaration dans le corps de la boucle pour.
Avantage possible
Considérez une seule boucle pour afficher toutes les valeurs des cellules d'une table carrée:
Avoir les deux variables dans l'instruction d'initialisation et dans la condition n'apporte aucun avantage en vitesse, par rapport à la situation où une boucle est imbriquée.
Cependant, si seules les valeurs sélectionnées dans le tableau sont à accéder, alors avoir les deux variables, dans l'instruction d'initialisation, dans l'instruction de condition et dans l'instruction Incrément, apporterait un avantage de vitesse; dans le sens où toutes les valeurs ne seront pas accessibles, avant d'éliminer beaucoup d'entre elles. Dans le programme suivant, toutes les autres paires de coordonnées, dans la diagonale principale, sont imprimées:
#inclure
Utilisation de Namespace Std;
int main()
pour (int i = 0, j = 0; i < 10 && j <10; i+=2,j+=2)
couter << i << ',' << j << ";
couter << endl;
retour 0;
La sortie est:
0,0 2,2 4,4 6,6 8,8
Il n'y a encore qu'une seule déclaration dans la boucle. Gagner un avantage en vitesse, de cette manière, implique d'inclure une logique sélective supplémentaire dans l'instruction de condition et / ou dans l'instruction Incrément. Les expressions d'initialisation dans l'instruction d'initialisation peuvent ne pas avoir à être initialisées à zéro.
Dans le code ci-dessus, l'instruction Incrément est:
i + = 2, j + = 2
ce qui signifie,
i = i + 2, j = j + 2;
Conclusion
Oui, je peux déclarer plusieurs variables dans une boucle pour. Et vous aussi, vous pouvez désormais déclarer plusieurs variables, dans une boucle, comme suit: séparez simplement les multiples variables de l'instruction d'initialisation avec des virgules. N'oubliez pas de mettre fin à l'instruction d'initialisation complète avec un point-virgule. Si l'accès des éléments de la structure doit être sélectif, ces variables peuvent également être utilisées, dans les déclarations de condition et / ou d'incrément, dans les parenthèses de la boucle for, peut-être avec une logique supplémentaire.