Cours complet d’initiation à la programmation

Le type bool est le type des expressions booléennes permettant d'écrire les conditions des instructions if et while. Les données de ce type ne peuvent prendre que deux valeurs.

Nom : bool
Ensemble des valeurs : true, false
Littéraux : true et false
Opérateurs : &&, || , not

Exemple 1 :

# true;;
- : bool = true
# not(true);;
- : bool = false
# true || false;;
- : bool = true

Le type int est le type des expressions numériques entières.

Nom : int
Ensemble des valeurs : le type int est limité aux entiers appartenant à un intervalle [[e_min,e_max]], et il y a donc un plus petit et un plus grand entier. Cet intervalle dépend de l'architecture du processeur de l'ordinateur utilisé. Sur des architectures 32 bits, on a

Sur des architectures 64 bits, on a

Littéraux : les entiers dans leur forme écrite usuelle. Par exemple : 24.
Constantes prédéfinies : les constantes min_int et max_int donnent les valeurs du plus petit (e_min) et du plus grand (e_max) entier.
Opérateurs arithmétiques : +, -, *, /, mod
Opérateurs de comparaison : =, <>, <, <=, >, >=

Remarque : Les calculs arithmétiques sur les nombres de type int s'effectuent modulo e_max - e_min + 1.

Exemple 2 :

La session ci-dessous est effectuée sur une machine 32 bits.

# (1+2) *3;;
- : int = 9
# 9 / 2;;
- : int = 4
# 9 mod 5;;
- : int = 4
# max_int;;
- : int = 1073741823
# min_int;;
- : int = -1073741824
# max_int + 1;;
- : int = -1073741824
# min_int - 1;;
- : int = 1073741823

Les nombres flottants sont définis avec le mot clé  : float

Le module Cartes définit deux types couleur et numero_tas(11).

Nom : couleur.
Ensemble des valeurs : Les données de ce type ne peuvent prendre que quatre valeurs notées : CARREAU, TREFLE, PIQUE et COEUR.
Nom : numero_tas.
Ensemble des valeurs : Les données de ce type ne peuvent prendre que quatre valeurs : 1, 2, 3 et 4.

Les variables servent à nommer des valeurs.

Elles sont caractérisées par leur nom ou identificateur, leur type et leur valeur.

La déclaration des variables se fait à l'aide du mot réservé (ou mot-clé) let.

let < identificateur > = < expression >

où <identificateur> est le nom de la variable, et <expression> l'expression qui définit sa valeur.

Exemple 3 :

Voici la déclaration d'une variable nommée a, de type int et de valeur 12.

# let a = 12;;
val a : int = 12
# a;;
- : int = 12
# 2 * a;;
- : int = 24

L'expression qui définit la valeur d'une variable peut faire référence à d'autres variables à condition que celles-ci aient été préalablement déclarées.

Exemple 4 :

À la suite de la déclaration de la variable a qui précède, on peut déclarer une nouvelle variable b comme ci-dessous

# let b = 2*a + 1;;
val b : int = 25

Les variables sont nommées par un identificateur. En Caml, les identificateurs de variables doivent obligatoirement commencer par une lettre minuscule ou un blanc souligné (_) et peuvent être complétés par n'importe quelle quantité de lettres minuscules ou majuscules non accentuées, ou chiffres, ou blancs soulignés.

Exemple 5 :

Le tableau ci-dessous montre quelques exemples d'identificateurs de variables corrects et incorrects.

En plus de ces règles, certains mots ne peuvent pas être utilisés comme identificateurs : ce sont les mots réservés ou mots-clés du langage (cf annexe C.2C.2 Mots-clés du langage).

L'ensemble des variables définies dans un contexte de calcul s'appelle un environnement.

Lorsque l’on déclare une variable, on augmente l'environnement courant de cette nouvelle variable. Ainsi, si dans un certain environnement E₀ on déclare la variable

# let a = 12 ;;
val a : int = 12

l'environnement qui suit cette déclaration est augmenté d'une variable nommée a et de valeur 12, et l'environnement est maintenant

Après la déclaration

# let b = 5 ;;
val b : int = 5

l'environnement est

On voit donc que la déclaration de variables peut augmenter l'environnement. Mais rien ne peut faire diminuer l'environnement : une variable déclarée le reste pour toute la durée de la session.

Lorsqu'une expression contient une ou plusieurs variables, pour chacune de ces variables on cherche dans l'environnement courant la variable de même nom la plus récemment déclarée, et on la remplace par la valeur correspondante.

Par exemple dans l'environnement E₂ précédemment décrit, l'expression a*b est transformée en 12*5 qui finalement donne la valeur 60.

Nous l'avons vu un environnement ne peut qu'augmenter. Que se passe-t-il lorsque nous déclarons une variable dont le nom est identique à celui d'une variable déjà déclarée ? Que se passe-t-il si l’on déclare une nouvelle variable nommée a dans l'environnement E₂ ?

Et bien, rien de neuf. Une nouvelle variable est ajoutée à l'environnement. Par exemple, si dans l'environnement E₂ on fait la déclaration

# let a = 9 ;;
val a : int = 9

l'environnement devient

On constate que l'environnement E₂ contient deux variables de même nom a : l'une valant 12 qui dans le temps a été la première à être déclarée, l'autre valant 9 qui est la plus récente.

Quelle est alors la valeur de l'expression a*b dans l'environnement E₃ ? Dans l'expression, on remplace la variable b par sa valeur 5, mais qu'en est-il pour a ? 9 ou 12 ? La règle d'évaluation dit de choisir la valeur de la variable la plus récemment déclarée, autrement dit 9. Par conséquent, dans l'environnement E₃ l'expression a*b vaut 45.

Dans l'environnement E₃, toute référence à la variable a est une référence à la variable < a, 9 >. L'autre variable < a, 12 > est masquée par < a, 9 >.

Plusieurs variables peuvent être définies simultanément dans la même phrase let en utilisant le mot-clé and.

let < identificateur 1 > = < expression 1 >
and < identificateur 2 > = < expression 2 >
...
and < identificateur n > = < expression n >

Les expressions <expression_i> sont alors toutes évaluées dans l'environnement dans lequel la phrase de déclaration est exprimée.

Exemple 6 :

# let a = 1
  and b = 2;;
val a : int = 1
val b : int = 2
# a + b ;;
- : int = 3

# let c = 1. ;;
val c : float = 1.
# let d = c +. 2. ;;
val d : float = 3.

# let e = 1.
  and f = e +. 2. ;;
Unbound value e

Mais si une déclaration préalable a été faite il n'y a aucun problème.

# let e = -3.;;
val e : float = -3.
# let e = 1.
  and f = e +. 2. ;;
val e : float = 1.
val f : float = -1.

À noter que dans l'environnement obtenu après ces déclarations, la variable e vaut 1., et f vaut -1., autrement dit f a été calculée avec la valeur de e dans l'environnement précédent.

Nous l'avons vu, l'environnement courant des variables déclarées ne peut que croître. Cela peut poser deux problèmes :

• un accroissement inutile de l'environnement avec des variables qui ne servent pas, et qui peut provoquer un encombrement, voire une saturation de la mémoire ;
• un masquage de certaines variables lorsqu'on utilise un même nom.

Bien souvent, on éprouve le besoin de déclarer une variable pour faciliter l'écriture d'une expression et/ou optimiser son évaluation.

Par exemple, si nous souhaitons calculer l'expression

on pourrait écrire (en supposant que dans l'environnement courant il y ait deux variables a et b de valeurs flottantes)

sqrt(a**2. +. b**2.) *.
  (1. +. sqrt(a**2. +. b**2.)) /.
  (2. +. sqrt(a**2. +. b**2.))

mais cela n'est évidemment pas satisfaisant parce que d'une part l'expression n'est pas facilement lisible, et d'autre part dans son évaluation, la sous-expression kitxmlcodeinlinelatexdvp\sqrt{a^2+b^2}finkitxmlcodeinlinelatexdvp va être calculée trois fois.

Pour mener des calculs, il arrive souvent que, pour ne pas noyer le propos par de longues formules, on utilise des notations pour les simplifier. On « pose » que tel symbole vaut temporairement telle valeur, et ensuite on utilise ce symbole en lieu et place de celle-ci.

Sur notre exemple cela pourrait donner : soit kitxmlcodeinlinelatexdvp\alpha = \sqrt{a^2+b^2}finkitxmlcodeinlinelatexdvp dans l'expression

dont une traduction possible en Objective Caml est

let alpha = sqrt(a**2. +. b**2.)
alpha *. (1. +. alpha) /. (2. +. alpha)

Cette façon de mener le calcul remédie aux deux défauts signalés ci-dessus :

• le code est beaucoup plus lisible ;
• la sous-expression kitxmlcodeinlinelatexdvp\sqrt{a^2+b^2}finkitxmlcodeinlinelatexdvp n'est calculée qu'une seule fois, et donc on gagne en efficacité.

Cependant, en procédant de la sorte on a introduit dans l'environnement courant une nouvelle variable dont l'intérêt est limité au seul calcul de notre expression. Par la suite la variable kitxmlcodeinlinelatexdvp\alphafinkitxmlcodeinlinelatexdvp ne sera probablement plus utilisée mais persistera dans l'environnement : c'est une pollution.

Il existe une solution pour éviter la pollution de l'environnement par des variables d'intérêt temporaire : c'est la notion de variable locale à une expression.

Ce qui manque dans notre exemple c'est la traduction de « posons kitxmlcodeinlinelatexdvp\alpha = \dotsfinkitxmlcodeinlinelatexdvp dans l'expression… ». Il ne faut pas déclarer une variable, puis calculer une expression, mais déclarer une variable à utiliser dans une expression. En Objective Caml, cela se traduit avec la forme let … in …. Notre exemple devient alors

let alpha = sqrt(a**2. +. b**2.)
in
  alpha *. (1. +. alpha) /. (2. +. alpha)

Avec une telle déclaration, la variable alpha ne vient s'ajouter à l'environnement courant que pour la durée de l'évaluation de l'expression qui suit. Sitôt cette évaluation terminée, elle est supprimée, et n'existe donc pas dans l'environnement courant à l'issue du calcul. Il n'y a aucune différence entre l'environnement avant et après évaluation. Le problème de pollution d'environnement est réglé.

La syntaxe générale de déclaration de variables locales est donnée ci-dessous.

let < identificateur 1 > = < expression 1 >
and < identificateur 2 > = < expression 2 >
...
in
  < expression >

Les variables non locales déclarées par une simple forme let sont appelées variables globales par opposition à locales.

En Objective Caml, la forme let … n'est pas une expression et a fortiori n'est pas une instruction.

Utilisée dans une séquence d'instructions elle ne donne pas l'effet auquel on pourrait penser. Dans la séquence qui suit

# let a = 1 ;
  a + 1;;
Warning S: this expression should have type unit.
Unbound value a

on constate un avertissement sur le fait que la première partie n'a pas le type unit, et un message d'erreur montre que dans l'environnement courant la variable a n'est liée à aucune valeur, et ceci malgré la forme de la déclaration qui précède.

Utilisée dans une expression conditionnelle, elle provoque un message d'erreur de syntaxe.

# if true then begin
    let a = 1;
    print_string ("Fini")
  end ;;
Syntax error

De même dans les instructions répétées (boucle while ou for).

En revanche, la forme let … in … est une expression. À ce titre elle peut être encapsulée.

# let a = 1 in print_int a ;
  print_newline () ;;
1
- : unit = ()
# if true then begin
    let a = 1 in
      print_int (a+1)
  end ;;
2- : unit = ()

Un problème

• État initial : Tas 1 un nombre quelconque de cartes, les autres tas sont vides.
• État final : peu importe.
• But : afficher le nombre de cartes situées initialement sur le tas 1.

Algorithme

Une solution du problème consiste à déplacer (une à une) toutes les cartes du tas 1 vers un autre tas (le tas 2 par exemple), et à compter chaque déplacement effectué.

Comme on peut le voir, dans cet algorithme la valeur du compteur évolue durant son exécution.

Une variable dont la valeur peut évoluer durant l'exécution d'un programme est appelée variable mutable. Par opposition, nous nommerons parfois les variables non mutables des constantes.

La déclaration d'une variable mutable est analogue à celle de toute variable, si ce n'est l'emploi du mot-clé ref.

let < identificateur > = ref < expression >

Exemple 7 :

Déclaration d'une variable mutable compteur initialisée à 0.

# let compteur = ref 0 ;;
val compteur : int ref = {contents = 0}

Comme on peut le voir, cette variable n'est pas de type int, mais de type int ref. Et sa valeur est {contents = 0}.

# compteur ;;
- : int ref = {contents = 0}

Comme compteur n'est pas de type int, on ne peut pas l'utiliser tel quel dans le contexte d'une expression où l’on attend un int.

# compteur + 1;;
This expression has type int ref but is here used with type

Pour faire référence à la valeur d'une variable mutable dans une expression, on utilise le préfixe ! devant le nom de la variable.

Exemple 8 :

# !compteur ;;
- : int = 0
# !compteur + 1;;
- : int = 1
# !compteur;;
- : int = 0

Notez qu'après l'évaluation de la deuxième expression, la variable compteur a gardé la valeur 0.

Pour modifier la valeur d'une variable mutable, il faut utiliser l'instruction d'affectation.

L'affectation est une instruction qui permet de changer la valeur d'une variable mutable.

La syntaxe de cette instruction est

< identificateur > := < expression >

Le symbole := signifie que la valeur v de l'expression < expression > est affectée à la variable désignée par l'identificateur < identificateur >. Après l'exécution de cette instruction la variable < identificateur > vaut v.

Comme toute instruction, le résultat d'une affectation est la valeur () de type unit.

Exemples :

1. Pour mettre à zéro la variable compteur précédemment déclarée ;

    

   Sélectionnez

   1.
   2.
   3.
   

   (* compteur = xxx *)
   compteur := 0 ;
   (* compteur = 0 *)
   

2. Ajouter 1 au compteur ;

    

   Sélectionnez

   1.
   2.
   3.
   

   (* compteur = n *)
   compteur := !compteur + 1 ;
   (* compteur = n + 1 *)
   

Remarques :

1. Attention à ne pas confondre le symbole := utilisé en Caml pour l'instruction d'affectation, avec le symbole = utilisé comme opérateur de comparaison, ainsi que dans la déclaration de variables.

2. En programmation, on est souvent amené à utiliser des instructions du type

    

   Sélectionnez

   1.
   

   a := !a + 1
   

   qui augmentent de 1 la valeur d'une variable (mutable). Cette opération s'appelle incrémentation et on dit qu'on incrémente une variable.

   La décrémentation est la diminution de la valeur d'une variable.

    

   Sélectionnez

   1.
   

   a := !a - 1
   

3. On peut penser que le code suivant est équivalent à une incrémentation.

    

   Sélectionnez

   1.
   

   let a = a+1
   

   Il n'en est rien du tout ! Il s'agit d'une déclaration d'une nouvelle variable a qui vient masquer la précédente. De plus, on ne peut pas utiliser cette forme let dans une boucle.

   Par exemple, on peut écrire

    

   Sélectionnez

   1.
   2.
   3.
   4.
   5.
   6.
   7.
   8.
   9.
   10.
   11.
   12.
   13.
   

   # let a = ref 0 ;;
   val a : int ref = {contents = 0}
   # while !a < 5 do
       a := !a + 1;
       print_int !a;
       print_newline ()
     done ;;
   1
   2
   3
   4
   5
   - : unit = ()
   

   mais on ne peut pas écrire

    

   Sélectionnez

   1.
   2.
   3.
   4.
   5.
   6.
   7.
   8.
   

   # let a = 0 ;;
   val a : int ref = {contents = 0}
   # while a < 5 do
       let a = a + 1;
       print_int (a);
       print_newline () )
     done ;;
   Syntax error
   

4. L'affectation est une opération autorisée sur les variables mutables uniquement. Elle ne l'est pas sur les variables non mutables (ou constantes).

    

   Sélectionnez

   1.
   2.
   3.
   4.
   

   # let a = 1 ;;
   val a : int = 1
   # a := 2;;
   This expression has type int but is here used with type 'a ref