Les autres structures de controle C++

Les autres structures de controle

sequencement
Pour executer successivement une suite ’E_1’, ..., ’E_N’ d’instructions, on utilise la construction:
begin E_1; ... E_i; ... E_N; end ;;
Ce qui peut aussi s’´ecrire (E_1 ; ... ; E_i ; ... ; E_N) ;;. En fait, et contrairement `a des langages comme Pascal, caml ne fait pas de diff´erences entre la notion d’instruction (i.e. une construction du langage qui effectue une action) et celle d’expression (i.e. une construction du langage qui renvoie une valeur): en caml, toute “instruction” poss`ede une valeur. Le s´equencement ne fait pas exeption `a cette r`egle: la valeur de (E_1 ; ... ; E_i ; ... ; E_N) est celle de la derni`ere instruction/expression ex´ecut´ee, i.e. celle de ’E_N’. Bien sˆur, le s´equencement n’est utile que si les instructions/expressions ’E_i’ (de i =1` a i = N−1)r´ ealisent des “effets de bord” (i.e. modifient des “´etats-m´emoire”); c’est le cas des fonctions d’entr´ee/sortie. Signalons enfin que, en version 0.74, un avertissement est g´en´er´e si les expressions E_i ne sont pas toutes (de i =1` a i = N −1) de type unit: begin 1 ; 2 ; 3 ; () ; 4 end ;; Toplevel input: >begin 1 ; 2 ; 3 ; () ; 4 end ;; >^ Warning: this expression has type int, but is used with type unit. Toplevel input: >begin 1 ; 2 ; 3 ; () ; 4 end ;; >^ Warning: this expression has type int, but is used with type unit. Toplevel input: >begin 1 ; 2 ; 3 ; () ; 4 end ;; >^ Warning: this expression has type int, but is used with type unit. - : int = 4
Bien sˆur, la derni`ere expression E_N peut ˆetre d’un type quelconque.

boucles
Revenons une fois encore vers la factorielle pour consid´erer les couples (n,n!). On voit que l’on peut obtenir la suite de ces couples par la fonction (x,y) 7→ (x +1,xy) en prenant la pr´ecaution de consid´erer (1,1) comme premier ´el´ement de cette suite (et non (0,1)). En fait, c’est cette id´ ee qui a donn´e naissance `a la version r´ecursive terminale de la factorielle. ´ Ecrivons une fonction g´en´erale d’it´eration qui, ´etant donn´es un entier n, une fonction f, et un argument x, calcule fn(x), o` u f0 =( x 7→ x) et o`u o` u fn = f ◦ fn−1 = fn−1 ◦ f. Voici cettefonction:
let reciterer n f x = if n = 0 then x else it´erer (n - 1) f (f x) ;;
iterer : int -> (’a -> ’a) -> ’a -> ’a
La factorielle s’´ecrit alors:
let fact n = snd (it´erer n (function (x, y) -> (x + 1 , x * y)) (1, 1)) ;; LasuitedesnombresdeFibonaccis’´ecriraitdemani`ereanalogueenconsid´erantlafonction(x,y)7→ (y,x+ y). Nous pouvons g´en´eraliser la fonction ’it´erer’ en passant en argument, non plus un entier ’n’ indiquant le nombre d’it´eration `a effectuer, mais un pr´edicat ’p’ permettant de tester si oui ou non l’it´eration doit se poursuivre:
let rec appliquer_tant_quepfx= if (p x) then appliquer_tant_que p f (f x) else x ;;
appliquer_tant_que : (’a -> bool) -> (’a -> ’a) -> ’a -> ’a
Remarque importante. Faisons l’hypoth`ese que le calcul de ’f’ termine toujours (quelque soit l’argument donne a’ f’). Une propri´et´e essentielle de (it´erer n f x)est alors de toujours terminer; cette propri´et´e n’est plus assur´ee pour (appliquer_tant_que p f x)(mˆeme si le pr´edicat p termine toujours). Les deux fonctions ’it´erer’ et ’appliquer_tant_que’ vont respectivement correspondre `a ce que l’on peut faire avec une boucle ’for’ et avec une boucle ’while’. On reviendra ult´erieurement vers ce probleme.