Comment fonctionne le range-based for pour les tableaux simples?
Est-ce que cela se lit comme suit: " Dites-moi ce que fait une distance pour (avec des tableaux)? "
Je répondrai en supposant que - Prenons l'exemple suivant en utilisant des tableaux imbriqués:
int ia[3][4] = {{1,2,3,4},{5,6,7,8},{9,10,11,12}};
for (auto &pl : ia)
Version texte:
ia
est un tableau de tableaux ("tableau imbriqué"), contenant des [3]
tableaux, chacun contenant des [4]
valeurs. L'exemple ci-dessus effectue une boucle ia
par sa «plage» principale ( [3]
), et donc boucle des [3]
temps. Chaque boucle produit l' un des ia
des » [3]
valeurs primaires à partir de la première et se terminant par le dernier - un tableau contenant des [4]
valeurs.
- Première boucle:
pl
égale{1,2,3,4}
- Un tableau
- Deuxième boucle:
pl
égale{5,6,7,8}
- Un tableau
- Troisième boucle:
pl
equals {9,10,11,12}
- Un tableau
Avant d'expliquer le processus, voici quelques rappels amicaux sur les tableaux:
- Les tableaux sont interprétés comme des pointeurs vers leur première valeur - L'utilisation d'un tableau sans aucune itération renvoie l'adresse de la première valeur
pl
doit être une référence car nous ne pouvons pas copier de tableaux
- Avec les tableaux, lorsque vous ajoutez un nombre à l'objet de tableau lui-même, il avance autant de fois et `` pointe '' vers l'entrée équivalente - Si
n
est le nombre en question, alors ia[n]
est le même que *(ia+n)
(Nous déréférencer l'adresse qui est n
entrée forward), et ia+n
est identique à &ia[n]
(Nous obtenons l'adresse de cette entrée dans le tableau).
Voici ce qui se passe:
- Sur chaque boucle,
pl
est défini comme une référence à ia[n]
, avec n
égalité du nombre de boucles en cours à partir de 0. Donc, pl
c'est ia[0]
au premier tour, au second c'estia[1]
, et ainsi de suite. Il récupère la valeur via une itération.
- La boucle continue tant que
ia+n
est inférieur à end(ia)
.
... Et c'est à peu près tout.
C'est vraiment juste une façon simplifiée d'écrire ceci :
int ia[3][4] = {{1,2,3,4},{5,6,7,8},{9,10,11,12}};
for (int n = 0; n != 3; ++n)
auto &pl = ia[n];
Si votre tableau n'est pas imbriqué, alors ce processus devient un peu plus simple en ce qu'une référence n'est pas nécessaire, car la valeur itérée n'est pas un tableau mais plutôt une valeur `` normale '':
int ib[3] = {1,2,3};
for (auto pl : ib)
cout << pl;
for (int n = 0; n != 3; ++n)
cout << ib[n];
Quelques informations complémentaires
Et si nous ne voulions pas utiliser le auto
mot - clé lors de la créationpl
? À quoi cela ressemblerait-il?
Dans l'exemple suivant, pl
fait référence à un fichier array of four integers
. Sur chaque boucle pl
est donnée la valeur ia[n]
:
int ia[3][4] = {{1,2,3,4},{5,6,7,8},{9,10,11,12}};
for (int (&pl)[4] : ia)
Et ... c'est comme ça que ça marche, avec des informations supplémentaires pour balayer toute confusion. C'est juste une for
boucle «abrégée» qui compte automatiquement pour vous, mais qui manque d'un moyen de récupérer la boucle actuelle sans le faire manuellement.
for
. Mais au moment où ce tableau se désintègre en un pointeur, les informations de taille sont perdues.