Suivez-nous sur X
|
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z,
ALL
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
A propos d'Obligement
|
|
David Brunet
|
|
|
|
Programmation : C - les itérations
(Article écrit par Chorizo Kid et extrait d'A-News (Amiga News) - septembre 1988)
|
|
Initiation au C n°3 : les itérations
Tiens, aujourd'hui il fait beau, j'ai mangé des nouilles à midi et au fromage, je vais donc vous parler des itérations.
Tout comme le nombre de doigts de ma main droite s'il m'en manquait deux, les itérations sont au nombre de trois. Pour ceux
qui viennent de se lever, je précise qu'une itération est une boucle constituée d'instructions, avec dans la boucle un test.
Tant que avec test en début de boucle
while (<expression>)
<instruction>
|
Ici on commence par évaluer l'expression ; si elle est vraie, l'instruction est exécutée (je vous rappelle que <instruction>
peut être une instruction simple ou bien un bloc d'instructions).
Attention, les lignes qui vont suivre sont un exemple :
Ce programme nous permet d'initialiser un vecteur de nombres entrés au clavier. On termine en entrant 999.
On utilise "printf" et "scanf" donc on doit faire le #include.
Puis on déclare un vecteur de 100 entiers (t[0], t[1],..., t[99]), chacun des t[rang] contiendra un "nombre".
On lit alors le premier nombre, puis on entre dans la boucle "while". Tant que le nombre est différent de 999,
on range "nombre" dans t[rang] puis on passe au rang suivant. On lit alors un nouveau "nombre".
Tant que avec test en fin de boucle
do
<instruction>
while (<condition>);
|
Avec ce type de boucle le "corps" de la boucle est toujours exécuté au moins une fois : voyons cela sur l'exemple précédent.
Ce programme fait la même chose que le précédent, mais ici la saisie du nombre n'a pas besoin d'être répétée deux fois. Dans le
cas du "while" il fallait connaître la valeur de nombre avant de passer dans le test de la condition. Pour le "do" la condition
est à la fin donc plus de problèmes.
En revanche, si l'on entre 999 comme première valeur (vecteur vide) le "while" marchera bien (arrêt immédiat, pas de passage dans
la boucle) alors qu'avec le "do" l'arrêt se fera après la première affectation (t[0]) vaudra 999).
Nous utilisons également des optimisations qui font la force du C : lorsque vous devez écrire variable = variable + 1; le C
permet (et il faut le faire) d'écrire variable++; : c'est la postincrémentation où ++variable; : c'est la
préincrémentation.
Soit ici : t[rang++]=nombre;
"nombre" est donc affecté à t[rang] puis "rang" est incrémenté grâce au ++.
Si l'on avait utilisé la préincrémentation t[++rang]=nombre;, "rang" aurait d'abord été incrémenté, puis "nombre" aurait été
affecté à t[rang].
Dans notre cas, il nous faut utiliser la postincrémentation puisque nous voulons affecter t[0] :
Forme générale d'une itération
for (<expression1>; <expression2>; <expression3>)
<instruction>
|
L'expression1 est évaluée (initialisation). On entre dans une boucle où si l'expression2 est vraie, on exécute l'instruction
puis on évalue l'expression3 (correspondant au "next" en BASIC), sinon on sort de la boucle.
Exemple :
for (indice=1;indice<=10;indice++)
printf("%i ",indice);
|
...va afficher les nombres de 1 à 10 : "indice" est initialisé à 1, puis tant que "indice" est inférieur ou égal à 10 on
l'affiche, puis on l'incrémente (indice++).
La boucle "for" est utilisée lorsque l'on connaît le nombre de passages dans la boucle (ici 10 fois).
Les boucles "while" ou "do" le sont lorsqu'on ne connaît pas le nombre de passages (on s'arrête quand on rencontre 999).
Reprenons l'exemple du début : notre vecteur t[] est initialisé et nous connaissons le nombre de ses éléments (rang).
Nous voulons maintenant calculer la somme des rang nombres du tableau t :
Même ceux qui avaient des Thomson ont dû comprendre.
Une autre optimisation du C que vous devez faire est la suivante : au lieu d'écrire somme=somme+t[indice];
écrivez somme+=t[indice];.
De même, x=x*10 s'écrira x*=10; de même avec /=, -=, etc.
En optimisant au maximum, ce qui est le but du C, on va obtenir un corps de boucle vide :
...
/* ... calcul de la somme */
for (indice=somme=0;indice<rang;somme+=t[indice++]);
printf("la somme est %i",somme);
|
Gééééééniaaaaaaal !
A l'initialisation de la boucle on en profite pour également initialiser somme à 0 (attention : "indice" doit rester en premier).
C'est là encore un des avantages du C. Exemple :
a=b=2+(c=3); c vaudra 3, a et b 5.
L'expression3 a elle aussi bénéficié des optimisations possibles : somme=somme+ ... et postincrémentation de "indice"
pour le prochain tour de boucle.
Finito
C'est tout pour ce mois. Que l'automne vous prenne sous son aile mordorée et que la joie envahisse vos yeux ébahis
d'enfant incrédule, pédalier-dérailleur (de cheval !).
|