Tutoriel OCaml Partie 2 : Nombres, Calculs, Variables et Références

06/02/2008 a 22h02 | 1662 hits

Vous avez à présent tous les outils pour programmer en OCaml, pour débuter dans ce langage, nous allons commencer par voire comment faire des calculs, puis comment enregistrer des nombres

Tout au long de ce tutoriel, vous aurez besoin de l'interpréteur OCaml, dont j'ai détaillé l'ouverture dans la partie précédente .
Une fois l'interpréteur ouvert, vous devriez avoir ceci :

        Objective Caml version 3.09.2



# 

Les Nombres

Avant de faire quoique ce soit considérez une chose : les nombres ont différents types suivant qu'ils sont décimaux ou entiers ! ("float" pour décimal, "int" pour entier)
En effet, vous verrez tout au long du tutoriel que l'OCaml est un langage fortement typé, cependant, vous n'aurez pas à définir le type ! Grâce à "l'inférence des types", OCaml détecte tout seul si vous utilisez des nombres entiers ou décimaux .
Donc, vous ne vous soucierez gère du typage, cependant, il vous est impossible de réaliser un opération sur deux nombres de type différent ! (par exemple, soustaire 1 par 2.5), mais heureusement, vous aurez certaine fonction pour convertir des int en float ou des float en int .
Mais trêve de bavardage, voyons de suite comment créer un nombre entier :

# 5;;

- : int = 5

(Vous tapez dans votre console "5 ;;")
Tout d'abord remarquez comment se définir une instruction : ..... ;;
Chaque instruction est séparée par deux points virgules (mais vous verrez que ce n'est pas toujours le cas)

Bien, voyons ce que OCaml nous a retourné : "- : int = 5"
_ le "-" signifie que aucune variable ne prend la valeur suivie par le ":" (ne vous en souciez pas en faite)
_ le "int" signifie que vous venez de taper un nombre entier qui a pour valeur "5"

Essayons autre chose :

# 7.0008;;   

- : float = 7.0008

Une chose à changé : vous n'avez plus de "int", mais un "float", en effet, OCaml à repéré que vous avez entré un nombre décimal !

Pour info, sachez qu'un nombre décimal utilise plus d'octet en mémoire qu'un nombre entier !

Les opérations de bases

Ecrire des nombres, c'est peu utile ! faire des opérations, c'est déjà plus intéressant !
Pour faire des calculs, on utilise des opérateurs, dont le comportement est définie par une fonction associée (mais ne vous en occupez pas, on vois les fonctions juste après)

voici les différents type d'opérateur : + - / +. -. /.
6 opérateurs différents pour 3 types d'action : addition, soustraction, division ! Cependant, il y a bien une différence en + et +. ! "+ - /" est utilisé pour des opérations sur des nombres entiers, et "+. -. /." est utilisé pour des opérations sur des nombres décimaux .

# 3+7;;   

- : int = 10

Une opération de nombres entiers retourne un nombre entier.

# 2.1 *. 3.8;;

- : float = 7.97999999999999954

Une opération de nombres décimaux retourne un nombre décimal.

Mais comment faire si l'on souhaite réaliser des opérations sur deux types de nombres différents ? Par exemple, si j'ai 2 € le kilo de tomate, et que j'ai 0.350 kg de tomate, comment vais-je faire pour trouver le prix puisque j'ai un nombre entier et un nombre décimal ? Alors, évidemment, on peut transformer notre 2 € en 2.0 €, mais je ne le souhaite pas !
Comment faire donc ? Comme je l'ai dit plus haut, il existe des fonctions (comme en math) pour convertir des entiers en flottants ou des flottants en entiers : float_of_int et int_of_float
Nous verrons l'utilisation de fonction plus en détail dans la partie suivante.

Donc pour résoudre notre problème de tomate :

# 0.350 *. float_of_int(2);;

- : float = 0.7

J'en aurais donc pour 70 centimes . Peut être que vous trouvez le nom de ces deux fonctions trop longue ? et bien, il existe des fonctions raccourcies : float et int ! Oui Oui ! Regardez :

# 0.350 *. float(2);;

- : float = 0.7

Encore plus simple non ? Et oui, contrairement au langage tel que le C, vous pouvez définir des fonctions ayant le même nom que des types !

Les variables

Comment enregistrer tout ces nombres ? En math on utilise des variables, dans tout les langages de programmation, c'est la même chose !

Toute variable ce définie par le mot clé "let", puis le nom de la variable (le "-" de tout à l'heure ;) ), et enfin, vous devez lui assigner une valeur qu'elle gardera jusqu'à la fin de votre programme !
[ocaml]let nom = valeur;;[/ocaml]

Par exemple, faisons une variable pour stocker mon âge :

# let age = 15;;

val age : int = 15

Cette fois, il n'y a plus de "-", mais le nom de la variable, le type de la variable ("int") et la valeur qui lui est assigné (15).

Vous pouvez la rappeler quand vous voulez dans votre programme :

# age;;

- : int = 15

# float(age) *. 2.5;;

- : float = 37.5

# let age_majeur = 18;;

val age_majeur : int = 18

# age_majeur - age;;

- : int = 3

# let difference = age_majeur - age;;     

val difference : int = 3

Les références

Vous savez à présent comment contenir un nombre dans une variable, cependant, vous ne pouvez pas modifier la valeur de la variable (du moins, pas en OCaml) .
En effet, si je dis au départ que j'ai 15 ans, puis que je viens de me souvenir qu'en faite j'en ai 18, vous ne pouvez pas faire ceci :

# let age = 15;;

val age : int = 15

# let age = 18;;

val age : int = 18

Car vous recréez une variable ! Elle n'est pas modifiée puisque vous ré-utilisez "let" !
Comment faire alors ? Il suffit d'utiliser des références ! Vous avez 4 choses à savoir :

* Une référence se déclare comme ceci : "let nom = ref (valeur);;"
* Pour modifier la valeur d'une référence, il faut faire ceci : "nom := valeur;;"
* On obtient la référence comme ceci : "nom;;"
* Pour obtenir la valeur assigné à une référence, il faut faire ceci : "!nom;;"

# let age = ref 14;;

val age : int ref = {contents = 14}

# age := 18;;

- : unit = ()

# age;;

- : int ref = {contents = 18}

# !age;;

- : int = 18

En faite, une référence à son type propre : "int/float ref" (notez qu'il n'y a pas que des int ou des float, nous verrons plus tard qu'il existe bien d'autres types tels que les string)

Pour ceux ayant pratiquer d'autres langages de programmation tel que le c, vous pouvez considérer une référence comme un pointeur, !nom correspondant à *nom ...


Voici un exemple final mélangeant les variables et les références :

# let majeur = 18;;

val majeur : int = 18

# let age = ref 15;;

val age : int ref = {contents = 15}

# let difference = ref (majeur - !age);;

val difference : int ref = {contents = 3}

# !difference ;;

- : int = 3

# let copy = difference;;

val copy : int ref = {contents = 3}

# !copy;;

- : int = 3

# age := 20;;    

- : unit = ()

# difference := majeur - !age;;

- : unit = ()

# copy;;

- : int ref = {contents = -2}

Je tiendrais à préciser encore sur la différence entre "nom" et "!nom", comme vous pouvez le voir, j'ai créé une référence "copy", cependant il n'y a pas le mot clé "ref", normal puisque j'ai copié une autre référence (je n'en ai pas créé une nouvelle) . Ce qui veut dire que toute valeur modifié dans !copy sera aussi modifié dans !différence ! Ces deux références partagent la même zone de mémoire dans votre RAM, modifier l'une revient à modifier l'autre !

En faite, une référence est composé de deux choses :
_ une adresse dans la RAM unique, qui définie la zone de mémoire allouer pour sa valeur, cette adresse n'est pas modifiable (si on pouvais la modifier, on changerais d'adresse, et donc de valeur, une valeur inconnu qui ne nous est pas destiné : d'un part, c'est impossible à faire, et d'autre part c'est une opération illégale) .
_ sa valeur à l'adresse précédente, sa valeur est, quant à elle, modifiable .



C'est terminé sur le chapitre des nombres et variables, dans le prochain chapitre, nous verrons en détail comment fonctionne les fonctions !

retour lire/ajouter des commentaires [1]