IdentifiantMot de passe
Mot de passe oublié ?Je m'inscris ! (gratuit)

Présentation d'Objective-Caml

Date de publication : 01/11/2006 , Date de mise à jour : 13/07/2007


 

IV. Structures de contrôle impératives
IV-1. Quelques types primitifs
. Séquence d'instructions
IV-3. Boucles et effets de bord


IV. Structures de contrôle impératives


IV-1. Quelques types primitifs

Comme de nombreux langages, OCaml utilise parfois des types primitifs, c'est-à-dire des types dont les représentants sont codés directement dans un format utilisé par la machine, et non construits de toute pièce, et ce afin d'améliorer ses performances. Ainsi, OCaml n'utilise pas la construction des entiers de Church, ce qui évite de devoir traiter une chaine de successeurs avant de connaître sa valeur. Parmi ces types primitifs nous pouvons citer les entiers (int), les nombres réels (float), les chaînes de caractères (string), etc.


. Séquence d'instructions

OCaml permet d'effectuer des séquences d'instructions, afin de chaîner certains traitements 

instruction_1 ;
instruction_2 ;
...
instruction_N-1 ;
instruction N
info Ce genre de traitement est également possible en programmation fonctionnelle à condition d'ignorer les paramètres de retour. 

let _ = instruction_1 in
let _ = instruction_2 in
...
let _ = instruction_N-1 in
instruction N

IV-3. Boucles et effets de bord

OCaml possède deux types de boucles d'itération :

  • while qui permet d'effectuer un nombre d'itérations non borné ; 

while (condition) do
   ...
done
  • for qui permet d'effectuer un nombre d'itérations borné. 

for i=1 to N do
   ...
done
OCaml dispose également de moyens pour effectuer des effets de bord, comme :

  • afficher des valeurs, au moyen des fonctions print_* ; 

# print_int 1;;
1- : unit = ()
# print_char 'a';;
a- : unit = ()
# print_string "abc";;
abc- : unit = ()
  • modifier des valeurs, au moyen de références (mot-clé ref) ou de champs mutable dans les enregistrements. 

# let i = ref 1 in
  i := !i + 1 ;
  !i;;
-: int = 2
# type 'a vector = { size : int ; mutable index : int };;
# let myvar = {size = 5 ; index = 0} ;;
val myvar : 'a vector = {size = 5; index = 0}
# myvar.index <- 4 ;
  myvar;;
val myvar : 'a vector = {size = 5; index = 4}
# myvar.size <- 4 ;;
The record field label size is not mutable
Toutefois, il est possible de s'abstraire quelque peu d'un tel traitement manuel grâce à certains modules (Array, Printf, ...) 

Array.make -: int -> 'a -> 'a array = <fun>
Array.length -: 'a array -> int = <fun>
Array.iter -: ('a -> unit) -> 'a array -> unit = <fun>
Array.map -: ('a -> 'b) -> 'a array -> 'b array = <fun>
...
Ainsi, on peut facilement effectuer d'affichage des éléments d'un tableau de ce type : 

let n = 10 in
let tab = Array.make n 0 in
for i=0 to n-1 do
   print_int tab.(i) ;
   print_newline () ;
done
Cela peut s'effectuer, de manière plus élégante, ainsi : 

let n = 10 in
let tab = Array.make n 0 in
Array.iter (fun i -> Printf.printf "%d\n" i) tab

 
 

Valid XHTML 1.1!Valid CSS!

Copyright (c) 2006-2007 Antonio Pasinelli, Nicolas Vallée. Permission is granted to copy and distribute under the terms of the Creative Commons licence, Version 3.0 or any later version published by the Creative Commons Corporation; with Attribution, No Commercial Use and No Derivs. Read the full license here : http://creativecommons.org/licenses/by-nc-nd/3.0/legalcode