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 du langage (entier, texte, valeur logique...) Par exemple, la ligne suivante est une expression effectuant une addition:: 5 + 6 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 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} On voit qu'une expression peut-être complexe, dans tous les cas une valeur est renvoyée. Les déclarations ~~~~~~~~~~~~~~~~ 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 : - Déclarations de types primitifs et conversions de type - 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 -------- .. 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 Les fonctions ------------- Préliminaire : rappel de théorie de l'information ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Théorie de l'information (Claude Shannon, 1949), (ou théorie de la communication) Canal de transmission:: entrée -> récepteur -> émetteur -> sortie Description d'une procédure ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ En programmation impérative, un programme est une suite d’instructions qui font évoluer l’état mémoire, le résultat est dans l’état final de la mémoire. - une procédure peut prendre des paramètres - elle modifie l'état courant du système - Déclaration des paramètes - Déclaration du corps - Appel de la procédure .. raw:: latex \begin{algorithm} \caption{Procédure de permutation de deux entiers}\label{permutation} \begin{algorithmic}[1] \Procedure{permuter}{$a,b$}{} \BState \emph{parametres}: \State $a: \textit{int}$ \State $b: \textit{int}$ \BState \emph{locales}: \State $z: \textit{int}$ \Comment{Une variable intermédiaire est nécessaire} \BState \emph{corps}: \State $z \gets a$ \State $a \gets b$ \State $b \gets z$ \EndProcedure \State \Call{permuter}{10, 12} \Comment{appel de la procédure} \end{algorithmic} \end{algorithm} effet de bord toute modification de la mémoire ou modification d'un support externe instruction commande ou phrase en mesure de modifier l'état du programme ou de la machine hôte (allocation mémoire, support externe, disque, écran...) Une procédure ne renvoie pas de valeur, mais provoque un 'effet de bord' (écriture dans une globale, dans un flux sortant etc.). Une procédure permet de créer une instruction nouvelle qui deviendra une primitive pour le programmeur. Cela permet de structurer le texte source du programme et améliorer sa lisibilité. Cela permet aussi d'appeler plusieurs fois, et à plusieurs endroit dans le code, cette primitive. Appel d'une procédure ~~~~~~~~~~~~~~~~~~~~~ (ex: pseudo-pascal) **déclaration de procédure** .. raw:: latex \begin{algorithm} \caption{Procédure de permutation de deux entiers}\label{permutation} \begin{algorithmic}[1] \Procedure{permuter}{$a,b$}{} \BState \emph{parametres}: \State $a: \textit{int}$ \Comment{paramètres formels de la procédure} \State $b: \textit{int}$ \BState \emph{locales}: \State $z: \textit{int}$ \Comment{les variables locales de la procédure} \BState \emph{corps}: \State ... \Comment{Le corps de la procedure} \EndProcedure \State \Call{permuter}{10, 12} \Comment{l'appel de la procédure} \end{algorithmic} \end{algorithm} - les variables x1,...,xn sont appelées *paramètres formels* de p - les variables v1,...,vm sont appelées *les variables locales* de p les valeurs effectivement passées en paramètres, ici `10, 12` sont appelées **paramètres effectifs** de p signature C'est l'ensemble paramètre formel + resultat de l'appel fermeture L'ensemble procédure + variables locales + signature + parametres effectifs est appelé une **fermeture**. C'est la procédure + son contexte qui permet de l'instancier dans un programme. niveau Le niveau d’une déclaration (de variable ou de procédure) est le nombre de procédures sous lesquelles elle est déclarée. Le programme principal a le niveau 0. Description d'une fonction ~~~~~~~~~~~~~~~~~~~~~~~~~~ Une fonction renvoie une valeur et ne modifie pas l'état courant du programme en cours d'exécution ni ne réalise d'effets de bord. Elle renvoie **toujours** quelque chose (même la valeur ``None`` qui n'est pas rien) - une procédure peut prendre des paramètres - elle modifie l'état courant du système - Déclaration des paramètes - Déclaration du corps - Appel de la fonction En programmation fonctionnelle, programme est un ensemble de définitions de fonctions, un résultat est l'application d’une fonction à une structure de données effective. - composant de base : la fonction - opération de base : l’application .. raw:: latex \begin{algorithm} \caption{Exemple de fonction}\label{fonction} \begin{algorithmic}[1] \Function{permuter}{$a,b$}{} \Comment{définition de la fonction} \BState \emph{parametres}: \Comment{déclaration (noms, types) des paramètres formels} \State $a: \textit{int}$ \State $b: \textit{int}$ \BState \emph{locales}: \Comment{déclaration (noms, types) des valeurs locales} \State $z: \textit{int}$ \BState \emph{corps}: \State $z \gets a$ \State $a \gets b$ \State $b \gets z$ \BState \emph{return}: \Comment{La valeur, le résulat renvoyé par la fonction} \EndFunction \State \Call{permuter}{10, 12} \Comment{appel de la fonction} \BState \emph{result}: \State (12, 10) \Comment{Le résultat effectif de la fonction après appel} \end{algorithmic} \end{algorithm}