390 lines
11 KiB
Plaintext
390 lines
11 KiB
Plaintext
Définition d'un programme
|
||
==========================
|
||
|
||
Qu'est-ce qu'un programme ?
|
||
----------------------------
|
||
|
||
- Un **programme** est une suite de **phrases** ;
|
||
- Une **phrase** est une **déclaration** ou une **expression** (*statement* en anglais) ;
|
||
|
||
Production d'un programme :
|
||
|
||
1. on écrit le code source du programme ;
|
||
2. on demande au compilateur de le traduire en code machine : c'est la compilation du programme ;
|
||
3. on demande à la machine d'effectuer le code machine : c'est l'exécution du programme.
|
||
|
||
.. important::
|
||
|
||
L'introduction à la compilation et les différentes phases de la compilation
|
||
d'un programme sont des sujets qui ne seront pas traités dans ce cours.
|
||
|
||
Dans un programme de base, il y a deux fichiers :
|
||
|
||
1. un fichier contenant le code : c'est le source du programme.
|
||
2. un fichier contenant le code machine : c'est l'exécutable.
|
||
|
||
Que peut faire un programme lorsqu'il est exécuté ?
|
||
Le programme doit communiquer. S'il reste isolé, il ne pourra pas
|
||
produire quoi que ce soit. Voici les trois moyens de communication qu'a un
|
||
programme :
|
||
|
||
1. communiquer avec l'utilisateur,
|
||
2. communiquer avec des fichiers,
|
||
3. communiquer avec d'autres programmes.
|
||
|
||
Les expressions
|
||
----------------
|
||
|
||
expression
|
||
|
||
Une expression est une valeur caculée du langage, une opération arithmétique
|
||
qui retourne une valeur (entier, texte, valeur logique...).
|
||
C'est donc une suite sémantiquement correcte de **valeurs de base** et **d'opérateurs**
|
||
|
||
Par exemple, la ligne suivante est une expression effectuant une addition::
|
||
|
||
5 + 6
|
||
|
||
Expressions à partir de types de base
|
||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||
|
||
Autres exemples d'expressions :
|
||
|
||
- 5 est une expression de type int
|
||
- 4.5 est une expression de type float
|
||
- 'c' est une expression de type char
|
||
- true est une expression de type bool
|
||
- print ('c') est une expression de type None
|
||
- raw_input est une expression de type string
|
||
|
||
Expressions à partir de types produits
|
||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||
|
||
Les types construits permettent de structurer l’information.
|
||
|
||
- les produits (n-uplets)
|
||
|
||
.. code-block:: ocaml
|
||
|
||
# type complexe = float * float ;;
|
||
|
||
- les produits nommés (enregistrements)
|
||
|
||
.. code-block:: ocaml
|
||
|
||
# type adresse = { rue : string ; ville : string ; cp : int};;
|
||
# type fiche = {
|
||
nom : string ;
|
||
prenom : string ;
|
||
adresse : adresse ;
|
||
date naissance : int * int * int ;
|
||
tel fixe : string ;
|
||
portable : string
|
||
};;
|
||
# let v1 = { a = 1 ; b = false ; c = 'r'};;
|
||
|
||
- les sommes (constructeurs)
|
||
|
||
.. code-block:: ocaml
|
||
|
||
# type couleur = Pique | Coeur | Carreau | Trefle;;
|
||
# let v = (Pique , Coeur);;
|
||
val v : couleur * couleur = (Pique , Coeur)
|
||
|
||
.. code-block:: ocaml
|
||
|
||
type nombre =
|
||
Ent of int | Reel of float | Cplx of float × float
|
||
Ent, Reel, Cplx sont les constructeurs du type.
|
||
|
||
On voit qu'une expression peut-être complexe, mais dans tous les cas une valeur
|
||
est renvoyée.
|
||
|
||
- les types séquences (listes)
|
||
|
||
.. code-block:: ocaml
|
||
|
||
# 4::1::5::8::1::[];;
|
||
- : int list = [4 ;1 ;5 ;8 ;1]
|
||
|
||
Algorithme de la longeur d'une liste
|
||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||
|
||
.. code-block:: ocaml
|
||
|
||
# let rec longueur l =
|
||
match l with
|
||
[] -> 0
|
||
| ::s -> 1 + (longueur s);;
|
||
|
||
Cette fonction est prédéfinie en Ocaml : `List.length`
|
||
|
||
Algorithme de tri par insertion
|
||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||
|
||
Cet algorithme de tri suit de manière naturelle la structure récursive des
|
||
listes. Soit l une liste à trier :
|
||
- si l est vide alors elle est déjà triée
|
||
- sinon, l est de la forme x::s et on trie récursivement la suite s et on obtient une liste triée s’
|
||
on insert x au bon endroit dans s’ et on obtient une liste triée
|
||
|
||
Description de l'algorithme
|
||
|
||
- la fonction inserer permet d’insérer un élément x dans une liste l
|
||
- si la liste l est triée alors x est inséré au bon endroit
|
||
|
||
.. code-block:: ocaml
|
||
|
||
# let rec inserer x l =
|
||
match l with
|
||
[] -> [x]
|
||
| y::s -> if x<=y then x::l else y::(inserer x s);;
|
||
val inserer : ’a -> ’a list -> ’a list
|
||
# inserer 5 [3 ;7 ;10];;
|
||
- : int list = [3 ; 5 ; 7 ; 10]
|
||
|
||
Algorithme de tri rapide
|
||
~~~~~~~~~~~~~~~~~~~~~~~~
|
||
|
||
soit une liste l à trier :
|
||
|
||
- si l est vide alors elle est triée
|
||
- sinon, choisir un élément p de la liste (le premier par exemple)
|
||
nommé le **pivot**
|
||
- partager l en deux listes g et d contenant les autres éléments de l
|
||
qui sont plus petits (resp. plus grands) que la valeur du pivot p
|
||
- trier récursivement g et d, on obtient deux listes g’ et d’ triées
|
||
|
||
.. code-block:: ocaml
|
||
:caption: fonction de partage d'une liste
|
||
|
||
#let rec partage p l =
|
||
match l with
|
||
[] -> ([] , [])
|
||
|x::s -> let g,d = partage p s in
|
||
if x<=p then (x::g , d) else (g , x::d) ;;
|
||
val partage : ’a -> ’a list -> ’a list * ’a list = <fun>
|
||
# partage 5 [1 ;9 ;7 ;3 ;2 ;4];;
|
||
- : int list * int list = ([1 ; 3 ; 2 ; 4], [9 ; 7])
|
||
|
||
.. code-block:: ocaml
|
||
:caption: algorithme de tri rapide
|
||
|
||
# let rec tri rapide l =
|
||
match l with
|
||
[] -> []
|
||
| p::s -> let g , d = partage p s in
|
||
(tri rapide g)@[p]@(tri rapide d) ;;
|
||
val tri rapide : ’a list -> ’a list = <fun>
|
||
# tri rapide [5 ; 1 ; 9 ; 7 ; 3 ; 2 ; 4];;
|
||
- : int list = [1 ; 2 ; 3 ; 4 ; 5 ; 7 ; 9]
|
||
|
||
|
||
Les listes chaînées
|
||
~~~~~~~~~~~~~~~~~~~~
|
||
|
||
.. code-block:: ocaml
|
||
|
||
typedef struct list{
|
||
int elt ;
|
||
struct list* suivant ;
|
||
} ;
|
||
|
||
Les déclarations
|
||
-----------------
|
||
|
||
Un autre exemple d'expression :
|
||
|
||
.. raw:: latex
|
||
|
||
\begin{algorithm}
|
||
\caption{Exemple d'expression}
|
||
\begin{algorithmic}[1]
|
||
\BState \emph{sortie}: $l$ \Comment{C'est l'expression calculée renvoyée}
|
||
\ForAll {$v \in V(G)$}
|
||
\State $l(v) \leftarrow \infty$
|
||
\EndFor
|
||
\State $l(u) \leftarrow 0$
|
||
\Repeat
|
||
\For {$i \leftarrow 1, n$}
|
||
\State $min \leftarrow l(v_i)$
|
||
\For {$j \leftarrow 1, n$}
|
||
\If {$min > e(v_i, v_j) + l(v_j)$}
|
||
\State $min \leftarrow e(v_i, v_j) + l(v_j)$
|
||
\State $p(i) \leftarrow v_j$
|
||
\EndIf
|
||
\EndFor
|
||
\State $l(i) \leftarrow min$
|
||
\EndFor
|
||
\State $changed \leftarrow l \not= l’$
|
||
\State $l \leftarrow l$
|
||
\Until{$\neg changed$}
|
||
\end{algorithmic}
|
||
\end{algorithm}
|
||
|
||
Exemple de déclarations :
|
||
|
||
- `a = 1`
|
||
- `b = 'c'`
|
||
|
||
.. important:: Le signe égal est utilisé de deux manières
|
||
|
||
- lors d'une déclaration d'une expression
|
||
- lorsque deux expressions sont équivalentes
|
||
|
||
Suivant les langages, il y a deux symboles différents, ou alors
|
||
ils sont identiques.
|
||
|
||
Il s'agit de **renseigner** une valeur dans une expression nommée
|
||
|
||
- en javascript :
|
||
|
||
.. code-block:: javascript
|
||
|
||
var b = "blabla" ;
|
||
|
||
- en python :
|
||
|
||
.. code-block:: python
|
||
|
||
b = "blabla"
|
||
|
||
- en java :
|
||
|
||
.. code-block:: java
|
||
|
||
String b = "A";
|
||
|
||
- en OCaml :
|
||
|
||
.. code-block:: ocaml
|
||
|
||
let a = 1
|
||
|
||
Grâce au mécanisme d'inférence de type dans OCaml, le mot-clef **let**
|
||
signifie ici véritablement l'instanciation d'une valeur au sens
|
||
mathématique du terme : soit `a` l'entier tel que a soit égal à 1...
|
||
|
||
En OCaml comme dans tous les langages fonctionnels, tout ce que nous avons l'habitude
|
||
d'appeler des "variables" à propos des affectations, sont en fait des **constantes**
|
||
au sens du paradigme impératif de la programmation.
|
||
|
||
.. important::
|
||
|
||
Par voie de conséquence, le symbole ``=`` est utilisé à la fois pour la définition des objets et pour le test d'égalité.
|
||
Pour les autres langages, on utilise `==` ou bien `===` (javascript) car
|
||
le `=` est sémantiquement déjà utilisé...
|
||
|
||
Toutes ces notation, apparemment anodines, correspondent donc à des paradigmes de programmation
|
||
|
||
Lorsqu'on ne déclare pas les types des symboles déclarés, c'est que soit
|
||
|
||
- le typage est faible
|
||
- le typage est dynamique (calcul du type en fonction du contenu de la
|
||
variable)
|
||
- le typage est statique et fort mais ça ne se voit pas
|
||
(var le système les calcule automatiquement par inférence de type)
|
||
|
||
Assigner, allouer, affecter une chose à quelqu'un ou à une autre chose.
|
||
|
||
Exemples dans la langue française :
|
||
|
||
- Le traitement que le budget **alloue** à ces fonctionnaires.
|
||
- Un système d'exploitation multitâche alloue le travail du processeur aux processus en attente, pour un bref laps de temps, à leur tour.
|
||
|
||
.. glossary::
|
||
|
||
affectation
|
||
|
||
Une affectation, aussi appelée assignation par anglicisme, est une structure qui permet d'attribuer une valeur à une variable.
|
||
|
||
Il s'agit d'une structure particulièrement courante en programmation impérative, et dispose souvent pour cette raison d'une notation courte et infixée,
|
||
comme ``x = expr`` ou ``x := expr`` ou encore `x <- expr`.
|
||
Dans certains langages, le symbole est considéré comme un opérateur d'affectation,
|
||
et la structure entière peut alors être utilisée comme une expression.
|
||
D'autres langages considèrent une affectation comme une instruction et ne permettent pas cet usage.
|
||
|
||
Voir aussi :
|
||
|
||
- Les déclarations de types primitifs et conversions de type
|
||
- Les types de base::
|
||
|
||
Octets (8 bits) byte
|
||
Entiers courts (16 bits) short
|
||
Entiers (32 bits) int
|
||
Entiers longs (64 bits) long
|
||
Réels (32 bits) float
|
||
Réels longs (64 bits) double
|
||
Caractères (16 bits) char
|
||
Booléens boolean
|
||
|
||
- Déclarations par lots::
|
||
|
||
x1 = e1, x2 = e2, ... xn = en;
|
||
|
||
Interaction avec l'utilisateur
|
||
------------------------------
|
||
|
||
Il est possible de communiquer de la manière suivante avec un programme :
|
||
|
||
- lire et écrire sur l'entrée/sortie standard
|
||
- lire et écrire dans un fichier
|
||
- afficher du texte ou un nombre
|
||
- lire du texte ou un nombre
|
||
- manipuler les prompts
|
||
|
||
La REPL (boucle d'interaction)
|
||
-------------------------------
|
||
|
||
.. glossary::
|
||
|
||
REPL
|
||
|
||
Read Eval Print Loop : outil principal de communication avec un programme
|
||
ou avec un système. Exemples : la console python, le prompt OCaml.
|
||
|
||
interface
|
||
|
||
outil de communication avec un programme.
|
||
|
||
- interface texte
|
||
- interface graphique
|
||
|
||
**Exemples de REPL**
|
||
|
||
Le prompt python::
|
||
|
||
Python 2.7.12 (default, Nov 19 2016, 06:48:10)
|
||
[GCC 5.4.0 20160609] on linux2
|
||
Type "help", "copyright", "credits" or "license" for more information.
|
||
>>>
|
||
>>> dir()
|
||
['__builtins__', '__doc__', '__name__', readline', 'rlcompleter']
|
||
>>>
|
||
|
||
Le prompt ipython::
|
||
|
||
Python 2.7.12 (default, Nov 19 2016, 06:48:10)
|
||
Type "copyright", "credits" or "license" for more information.
|
||
|
||
IPython 2.4.1 -- An enhanced Interactive Python.
|
||
? -> Introduction and overview of IPython's features.
|
||
%quickref -> Quick reference.
|
||
help -> Python's own help system.
|
||
object? -> Details about 'object', use 'object??' for extra details.
|
||
|
||
In [1]:
|
||
|
||
Le prompt OCaml (utop)::
|
||
|
||
Type #utop_help for help about using utop.
|
||
|
||
─( 09:21:24 )─< command 0 >──
|
||
utop #
|
||
# let x = 1 in x + 2;;
|
||
- : int = 3
|
||
# let y = 1 + 2;;
|
||
val y : int = 3
|
||
# y * y;;
|
||
- : int = 9
|