Exemple 1:
Le « iostream » est ici le premier fichier d’en-tête où les fonctions du C++ sont déclarées. Ensuite, nous ajoutons le fichier d'en-tête « vecteur » qui est inclus ici afin que nous puissions travailler avec le vecteur et la fonction pour opérer sur les vecteurs. Ensuite, « std » est l'espace de noms que nous insérons ici, nous n'avons donc pas besoin de mettre ce « std » avec toutes les fonctions individuellement dans ce code. Ensuite, le « main() » est invoqué ici. En dessous, nous créons un vecteur de type de données « int » avec le nom « myNewData » et y insérons des valeurs entières.
Après cela, nous plaçons la boucle « for » et utilisons ce mot-clé « auto » à l'intérieur. Désormais, cet itérateur détectera le type de données des valeurs ici. Nous obtenons les valeurs du vecteur « myNewData » et les enregistrons dans la variable « data » et les affichons également ici au fur et à mesure que nous ajoutons ces « data » dans le « cout ».
Codage 1 :
#include
#include
en utilisant espace de noms norme ;
int principal ( ) {
vecteur < int > mesNouvellesDonnées { onze , 22 , 33 , 44 , 55 , 66 } ;
pour ( auto données : mesNouvellesDonnées ) {
cout << données << fin ;
}
}
Sortir :
Nous avons vu toutes les valeurs de ce vecteur qui sont imprimées ici. Nous imprimons ces valeurs en utilisant la boucle « for » et en y plaçant le mot-clé « auto ».
Exemple 2 :
Ici, nous ajoutons le « bits/stdc++.h » car il contient toutes les déclarations de fonction. Ensuite, nous mettons ici l'espace de noms « std », puis invoquons le « main() ». En dessous, nous initialisons un « ensemble » de « chaîne » et le nommons « myString ». Ensuite, dans la ligne suivante, nous y insérons les données de chaîne. Nous insérons quelques noms de fruits dans cet ensemble en utilisant la méthode « insert() ».
Nous utilisons la boucle « for » en dessous et plaçons le mot-clé « auto » à l'intérieur. Après cela, nous initialisons un itérateur avec le nom « my_it » avec le mot-clé « auto » et lui attribuons « myString » avec la fonction «begin()».
Ensuite, nous plaçons une condition qui est « my_it » différente de « myString.end() » et incrémentons la valeur de l'itérateur en utilisant « my_it++ ». Après cela, nous plaçons le « *my_it » dans le « cout ». Désormais, il imprime les noms des fruits selon la séquence alphabétique, et le type de données est détecté automatiquement lorsque nous plaçons ici le mot-clé « auto ».
Code 2 :
#includeen utilisant espace de noms norme ;
int principal ( )
{
ensemble < chaîne > maChaîne ;
maChaîne. insérer ( { 'Raisins' , 'Orange' , 'Banane' , 'Poire' , 'Pomme' } ) ;
pour ( auto mon_it = maChaîne. commencer ( ) ; mon_it ! = maChaîne. fin ( ) ; mon_it ++ )
cout << * mon_it << ' ' ;
retour 0 ;
}
Sortir:
Ici, on peut remarquer que les noms des fruits sont affichés dans un ordre alphabétique. Toutes les données sont rendues ici et nous les avons insérées dans le jeu de chaînes car nous avons utilisé « for » et « auto » dans le code précédent.
Exemple 3 :
Puisque « bits/stdc++.h » contient déjà toutes les déclarations de fonction, nous l'ajoutons ici. Après avoir ajouté l'espace de noms « std », nous appelons « main() » à partir de cet emplacement. L'« ensemble » de « int » que nous avons établi dans la suite est appelé « myIntegers ». Ensuite, nous ajoutons les données entières dans la ligne qui suit. Nous utilisons la méthode « insert() » pour ajouter quelques entiers à cette liste. Le mot-clé « auto » est maintenant inséré dans la boucle « for » utilisée en dessous.
Ensuite, nous utilisons le mot-clé « auto » pour initialiser un itérateur avec le nom « new_it », en lui attribuant les fonctions « myIntegers » et «begin()». Ensuite, nous définissons une condition qui stipule que « my_it » ne doit pas être égal à « myIntegers.end() » et utilisons « new_it++ » pour augmenter la valeur de l'itérateur. Ensuite, nous insérons le « *new_it » dans cette section « cout ». Il imprime les entiers par ordre croissant. Lorsque le mot-clé « auto » est inséré, il détecte automatiquement le type de données.
Code 3 :
#includeen utilisant espace de noms norme ;
int principal ( )
{
ensemble < int > mesEntiers ;
mesEntiers. insérer ( { Quatre cinq , 31 , 87 , 14 , 97 , vingt-et-un , 55 } ) ;
pour ( auto nouveau_it = mesEntiers. commencer ( ) ; nouveau_it ! = mesEntiers. fin ( ) ; nouveau_it ++ )
cout << * nouveau_it << ' ' ;
retour 0 ;
}
Sortir :
Les nombres entiers sont affichés ici par ordre croissant, comme le montre ce qui suit. Puisque nous avons utilisé les termes « pour » et « auto » dans le code précédent, toutes les données que nous avons placées dans l'ensemble d'entiers sont restituées ici.
Exemple 4 :
Les fichiers d'en-tête « iostream » et « vector » sont inclus car nous travaillons avec les vecteurs ici. L'espace de noms « std » est ensuite ajouté et nous appelons ensuite le « main() ». Ensuite, nous initialisons un vecteur de type de données « int » avec le nom « myVectorV1 » et ajoutons quelques valeurs à ce vecteur. Maintenant, nous plaçons la boucle « for » et utilisons « auto » ici pour détecter le type de données. Nous accédons par valeurs du vecteur puis les imprimons en plaçant « valueOfVector » dans le « cout ».
Après cela, nous plaçons un autre « for » et le « auto » à l'intérieur et l'initialisons avec « && valueOfVector : myVectorV1 ». Ici, on accède par la référence puis on imprime toutes les valeurs en mettant « valueOfVector » dans le « cout ». Désormais, nous n'avons plus besoin d'insérer le type de données pour les deux boucles car nous utilisons le mot-clé « auto » à l'intérieur de la boucle.
Code 4 :
#include#include
en utilisant espace de noms norme ;
int principal ( ) {
vecteur < int > monVecteurV1 = { 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , dix } ;
pour ( auto valeurDeVecteur : monVecteurV1 )
cout << valeurDeVecteur << ' ' ;
cout << fin ;
pour ( auto && valeurDeVecteur : monVecteurV1 )
cout << valeurDeVecteur << ' ' ;
cout << fin ;
retour 0 ;
}
Sortir:
Toutes les données du vecteur sont affichées. Les nombres affichés dans la première ligne sont ceux auxquels nous avons accédé par valeurs, et les nombres affichés dans la deuxième ligne sont ceux auxquels nous avons accédé par référence dans le code.
Exemple 5 :
Après avoir appelé la méthode « main() » dans ce code, on initialise deux tableaux qui sont « myFirstArray » de taille « 7 » avec le type de données « int » et « mySecondArray » avec la taille « 7 » du « double » Type de données. Nous insérons les valeurs dans les deux tableaux. Dans le premier tableau, nous insérons les valeurs « entières ». Dans le deuxième tableau, nous ajoutons les valeurs « doubles ». Après cela, nous utilisons le « for » et insérons le « auto » dans cette boucle.
Ici, nous utilisons une boucle « range base for » pour le « myFirstArray ». Ensuite, on place « myVar » dans le « cout ». En dessous, nous plaçons à nouveau une boucle et utilisons la boucle « range base for ». Cette boucle est pour le « mySecondArray » et ensuite nous imprimons également les valeurs de ce tableau.
Code 5 :
#includeen utilisant espace de noms norme ;
int principal ( )
{
int monPremierArray [ 7 ] = { quinze , 25 , 35 , Quatre cinq , 55 , 65 , 75 } ;
double monSecondArray [ 7 ] = { 2,64 , 6h45 , 8.5 , 2.5 , 4.5 , 6.7 , 8.9 } ;
pour ( const auto & maVar : monPremierArray )
{
cout << maVar << ' ' ;
}
cout << fin ;
pour ( const auto & maVar : monSecondArray )
{
cout << maVar << ' ' ;
}
retour 0 ;
}
Sortir:
Toutes les données des deux vecteurs sont affichées dans ce résultat ici.
Conclusion
Le concept « for auto » est étudié en profondeur dans cet article. Nous avons expliqué que « auto » détecte le type de données sans le mentionner. Nous avons exploré plusieurs exemples dans cet article et avons également fourni l'explication du code ici. Nous avons expliqué en profondeur le fonctionnement de ce concept « pour auto » dans cet article.