Primitives fondamentales d'algorithmique

Présentation au sujet: "Primitives fondamentales d'algorithmique"— Transcription de la présentation:

1 Primitives fondamentales d'algorithmique
Les opérations d'un algorithmes sont habituellement exécutées une à la suite de l'autre, en séquence  ordre est important. (parallélisme) On ne peut pas arbitrairement changer cette séquence. Affectation Sélection Répétition

2 Branchement conditionnel
facultatif Branchement conditionnel if (condition) { instructions } else { } if (condition) instruction else test_2 test_2_vrai test_3_faux test_1 test_1_vrai test_faux test test_vrai

3 Branchement multiple switch (variable_énumérable) { case valeur_1 :
Tous les autres cas Ne pas oublier Type int Branchement multiple switch (variable_énumérable) { case valeur_1 : instructions ; break; case valeur_2 : default : } Pourquoi une nouvelle sélection ?

4 corps_boucle incr test init
Boucles indicées Contrôlée par un indice  nombre d’itérations connu à l’avance (déterministe). for ( initialisation ; condition_de_boucle ; évolution ) { instructions; } Éxécuté 1 fois Éxécuté à chaque fois Continue tant que condition = vrai corps_boucle incr test init for (init;test;incr) { corps_boucle; }

5 Boucles conditionnels
Contrôlée par une condition  nombre d’itérations inconnu par avance (indéterministe). while ( condition ) { instructions; } Continue tant que condition = vrai do { } while ( condition ) (On peut ne pas rentrer) (On rentre au moins une fois) corps_boucle test while (test) { corps_boucle; }

6 Méthodologie de résolution d'un problème
1- Définir le problème (QUOI ?) Lire l’énoncé du problème, être certain de bien le comprendre, ressortir les informations pertinentes : données ? résultats ? relations entre données ? Création du cahier des charges qui définie ces notions en détails. 2- Analyser le problème (COMMENT ?) Réfléchir à la résolution du problème en ignorant l’existence du PC - Expliciter les données et les résultats Définir précisément leur Nature : Simple, Structure, Domaine de validité - Expliciter les relations données/résultats exploiter l’ensemble de vos connaissances et solution existantes. encore difficile ? Décomposer le problème!! Analyse descendante!!

7 3- Résoudre le problème Algorithme = méthode de résolution. Pour décrire l'algorithme, il faut un langage algorithmique. Le langage algorithmique peut avoir plusieurs formes mais à quelques contraintes : Langage limité et précis. Écrire formellement l’algorithme en utilisant un pseudo langage ou un organigramme Vérifier votre solution sur un exemple (preuve formelle de l’algorithme) 4- Implémentation Transformer l'algorithme en programme Le programme sera compilé puis exécuté. 5- Validation des résultats Tester le programme sur différents jeux de tests le jeux de tests doit être « suffisant » ne pas oublier les cas particuliers, …

8 Savoir être : efficace : quelle méthode me permettra d’obtenir le plus vite, le plus clairement, le plus simplement possible les résultats attendus. paresseux : que puis-je réutiliser? prévoyant : s’assurer que le programme sera facilement réutilisable et extensible

9 Méthodes d’analyse Instance du problème
Exemple d’un problème: Tri d’un ensemble d’éléments Entrée: Suite de n éléments a1,…an Sortie: La suite ordonnée Instances du problème: Suite de nombres: 475, 787, 34, 245, 56, 350

10 Analyse descendante Objectifs: Méthode pour écrire un algorithme de qualité. Principe: Abstraire: Repousser le plus loin possible l’écriture de l’algorithme. Décomposer: Décomposer la résolution en une suite de “sous-problèmes” que l’on considère comme résolus. Combiner: Résoudre le pb par combinaison des abstractions des “sous-pbs”. Pb: Afficher les nbres parfaits compris entre 1 et un nbre saisi par l’utilisateur Énoncé: Afficher les nombres parfaits (nombre égaux à la somme de leurs diviseurs) compris entre 1 et un nombre n (naturel  1) saisi par l’utilisateur. afficherNbsParfaits entier saisirBorneMax booléen estParfait sommeDesDiviseurs entiers estUnDiviseur

11 Diviser pour régner La méthode d’analyse « diviser pour régner » :
on conçoit un ensemble de procédures pour résoudre le problème programmation dirigée par les traitements : on décide d’abord de la manière dont on va manipuler les données puis on conçoit les structures de données pour faciliter cette manipulation. une procédure est un regroupement d’instructions dans un bloc que l'on pourra appeler par son nom La méthode d’analyse « diviser pour régner » : Ces procédures reçoivent éventuellement des variables en paramètres et effectuent des traitements sur ces variables données en paramètres ou sur des variables déclarées à l’intérieur de la procédure. Une variable est un morceau de mémoire auquel on donne un nom et dans lequel on stocke des valeurs.

12 Apport de la démarche algorithmique
Décomposer une tâche complexe en tâches élémentaires. Penser en termes d’étapes. Vérifier la succession des opérations. Assurer la rigueur d’écriture.

13 Récursivité Il est parfois difficile de définir un objet: plus simple de le définir en fonction de lui-même. Récursion en programmation: quand une méthode s’appelle elle-même. Toute méthode récursive peut-être convertie en méthode non-récursive. Méthodes récursives plus coûteuses en espace mémoire, et parfois aussi en temps.  La récursivité est un mécanisme de calcul puissant!!  Résoudre un problème de taille n peut se ramener à la résolution d’un (plusieurs) sous problèmes de taille plus réduite ...

14 Exemple (suite) D’après la définition précédente :    «a» est une chaîne : un caractère ‘a’ suivi d’une chaîne vide   «ab» est une chaîne : un caractère ‘a’ suivi de la chaîne « b » La récursivité est un mécanisme puissant de définition d’objets!

15 Procédure récursive = 120 = 24 = 6 = 2 = 1 5! = 5.4! 4! = 4.3!
Procédure qui s’invoque elle-même Exemple: n! = n(n-1)(n-2)…2.1 Si n≥0 0! = 1 n! = n(n-1)! pour n≥1 5! = 5.4! 4! = 4.3! 3! = 3.2! 2! = 2.1! 1! = 1.0! = 120 = 24 = 6 = 2 = 1 Toute procédure récursive doit avoir une condition d’arrêt: cas de base qui permet de ne plus invoquer la procédure. Ici, la condition d’arrêt est n=0

16 factoriel(3) factoriel(2) factoriel(1) factoriel(0) Trace pour n =3:
Entrée: Entier n≥0 Sortie: n! Procédure factoriel (n) Si n = 0 alors Retourne (1) Retourne (n.factoriel(n-1)) Fin factoriel factoriel(3) Retourne: 3.factoriel(2) factoriel(2) Retourne: 2.factoriel(1) factoriel(1) Retourne: 1.factoriel(0) factoriel(0) 1.1=1 Retourne: 1 3.2=6 2.1=2

17 Procédure itérative pour le calcul de n!
Trace pour n =3 : Entrée: Entier n≥0 Sortie: n! Procédure factoriel-iteratif (n) res = 1; courant = n; Tant que courant>0 Faire res := res * courant; courant := courant-1; Fin Tant que Retourne (res) Fin factoriel-iteratif res=1 courant=3 res=3 courant=2 res=6 courant=1 res=6 courant=0

18 Nombres de Fibonacci Exemple: Un robot peu avancer par des pas de 1 ou 2 mètres. Calculer le nombre de façons différentes de parcourir une distance de n mètres Distance Suite de pas Nb de possibilités 1 2 1,1 ou 2 3 1, 1, 1 ou 1, 2 ou 2, 1 4 1,1,1,1 ou 1,1,2 ou 1,2,1 ou 2,1,1 ou 2,2 5

19 Pas(n): Nombre de possibilités pour parcourir n mètres.
Pas(1) = 1, Pas(2) = 2; Pour n>2: Si premier pas = 1 mètres, il reste n-1 mètres -> Pas(n-1) Si premier pas = 2 mètres, il reste n-2 mètres -> Pas(n-2) Donc, Pas(n) = Pas(n-1)+Pas(n-2) Entrée: n Sortie: Pas(n) Procédure Pas (n) Si n=1 ou n=2 alors Retourne (n) Retourne (Pas(n-1)+Pas(n-2)) Fin Pas Séquence de Fibonacci: f1 = 1 f2 = 2 fn = fn-1 + fn-2 pour n>2

20 Récursivité Vs Itération
procédure Itération( ) Tantque (condition) faire <Instructions> fin tantque Si (condition) alors Itération() fin si fonction S(n) : entier S :=0 Tant que (n>0) faire S:=S+n n:=n-1 fin tant que retourner S Si (n=0) alors S:= 0 sinon S:= S(n-1)+n Itération Récursivité

21 Diviser pour résoudre Principe général :
Diviser le problème de taille n en sous-problèmes plus petits de manière que la solution de chaque sous-problème facilite la construction du problème entier.(Analyse descendante) Division progressive jusqu' à l'obtention d'un sous-problème de taille 1. Schéma général : DPR(x) : Si x est suffisamment petit ou simple alors Retourner A(x) Sinon Décomposer x en sous exemplaires x1,x2...xk Pour i=1, k : yi := DPR(xi) Finpour Retourner les yi pour obtenir une solution à x Retourner y Fsi

22 Applications : Tri par fusion d'une liste L de n éléments avec n = 2k.
Une technique "diviser pour résoudre" peut être la suivante: Pour trier une liste de n éléments, il faut trier deux listes de n/2 éléments chacune puis de faire l'interclassement entre ces deux listes. De la même façon, pour trier une liste de n/2 éléments il faut trier deux listes de n/4 éléments chacune puis de faire leur interclassement. Et ainsi de suite jusqu'à l'obtention de listes d'un seul élément.

23 Les Tours de Hanoi A B C Peut-on bouger les disques de A vers C en utilisant B. Contrainte : un disque ne peut jamais être déposé sur un disque plus petit Y a-t-il une solution ?

24 A B C

25 Supposons qu’on ait n disques au départ
Les disques sont numérotés de 1 à n, par ordre croissant de diamètre. Algorithme : Bouger les n-1 plus petits disques de A à B en utilisant C Bouger le disque n de A à C Bouger les n-1 plus petits disques de B à C en utilisant A Complexité : 2^n-1 mouvements !!!

26 Décomposition modulaire
Quelques citations : « Pour comprendre un programme d ’un seul tenant, un être humain met normalement un temps qui augmente exponentiellement avec la taille du programme » Djikstra «Pour maîtriser la complexité du problème à résoudre, diviser chacune des difficultés que j’examinerais en autant de parcelles qu’il pourrait et qu ’il serait requis pour mieux le résoudre » Descartes stratégie "diviser pour régner »  permet d’alléger le programme, de faciliter sa Maintenance, de le Structurer, d’améliorer sa Lisibilité, Extensibilité et Réutilisation.

27 Les fonctions et procédures
Les fonctions sont au plus bas niveau de la décomposition d’un problème. Une fonction devrait avoir un seul but ou tâche à exécuter. Les fonctions sont représentées dans un graphe de structure qui est une hiérarchie (fonctionnelle). Une fonction est une abstraction parce qu’elle peut cacher les détails d’une tâche et elle réduit l’interface à des paramètres et une valeur de retour. Les procédures et les fonctions sont à la base de la programmation structurés

28 Attention : Danger du « Code spaghetti »
Avantages : Les fonctions nous permettent de factoriser nos problèmes en parties gérables et compréhensibles. Facilitent la distribution du travail. Permettent la réutilisation du code – bibliothèques et fonctions définies par les programmeurs de systèmes. Permettent de protéger les données de chaque fonction (visibilité). Vision très « top-down » de la programmation, tendance cartésienne analytique Attention : Danger du « Code spaghetti »

29 Déclaration et définition d’une fonction
Une fonction est déclarée avec un prototype qui consiste en un entête de fonction. La définition du code de la fonction c’est son implémentation entête Type_retour NomFonction (liste formelle de paramètres); { \*définitions locales + traitement *\ } \\ nom de la fonction corps Variable = NomFonction(Var1,Var2); appel Principe de la « boîte noire » Une procédure peut être assimilé à une « boîte noire », c’est à dire un module dont on peut ne connaître que les interactions possibles avec le monde extérieur : Procédure /fonction N entrées N sorties

30 En C nous pouvons décomposer une grosse fonction monolithique (main) en de plus petites fonctions cohésives. NB: Pour pouvoir faire un programme exécutable il faut toujours une fonction « main », c’est le point d’entrée dans le programme : le microprocesseur sait qu’il va commencer à exécuter les instructions à partir de cet endroit Ces fonctions peuvent être misent à l’intérieur d’un seul fichier: une unité de compilation Déclarer par des prototypes de fonctions. Une fonction peut avoir le type void Une fonction void ne peut pas faire partie d’une expression, elle peut seulement être un énoncé.

31 Le module C C nous fournit deux types de fichiers pour que nous puissions définir nos modules Le fichier .h – ou entête de module : Contient la déclaration des fonctions et les attributs que nous voulons que les autre modules voient. Aussi connue comme interface du module Le fichier .c – ou corps du module : Contient la définition des fonctions qui sont déclarées dans l’entête du module et autres fonctions internes ou de soutient. Connue comme implémentation du module

32 Modules = fonctions (déclaration / implémentation)
Communication entre modules = appels de fonctions Flexibilité et réutilisation par des pointeurs de fonctions Comprendre le programme  comprendre ce que fait chaque fonction. Pour les gros programmes, il ne suffit pas seulement de décomposer un programme en fonctions. Tout comme un édifice, un programme logiciel doit avoir une structure bien dessinée; une architecture L’architecture d’un gros programme doit être exprimée en unités de compilation séparées En C, ces unités de compilation sont des modules (ex. les bibliothèques de modules tel que stdio, conio, …)

33 Masquage d’information
Le concept de masquage d’information est clef pour les concepts de décomposition et d’abstraction. On cache l’information qui peut changer et on expose une interface stable qui ne changera pas. L’information est obtenue ou changée SEULEMENT en utilisant l’interface. Type et paramètres de fonction Il y a 2 façons principales pour échanger de l’information entre les fonctions : Variables partagées (variables globales). Passage de paramètres, la déclaration explicite d’information nécessaire pour qu’une fonction réalise sa tâche.

34 Variables locales et passage de paramètres
Utilisation d ’une procédure et passage de paramètres Passage par valeur Passage par adresse (par référence)

35 Inconvénients d'une utilisation systématique de variables globales
manque de lisibilité risque d'effets de bord si la procédure modifie les variables globales Avantages d'une utilisation de variables locales meilleure structuration. diminution des erreurs de programmation. les variables locales servent de variables intermédiaires (tampon) et sont "oubliées" (effacées de la mémoire) à la sortie de la procédure. Une procédure doit effectuer la tâche qui lui a été confiée, en ne modifiant que l'état de ses variables locales.

36 Structures de données Problème : “Comment Organiser au mieux l’information dans un Programme ?” Choisir la façon de représenter les données qui rendent le programme le plus efficace possible en temps, en espace etc. Listes linéaires chaînées : ensemble de nœuds alloués dynamiquement chaînés entre eux. un nœud est une entité de stockage. plus adapté aux instances de taille variable Arbres : structure de données hiérarchisée. Graphe : structure plus complexe représentant des relations entre éléments. Hachage : transformer une donnée (par une fonction) en une adresse où sera logée la donnée. (Gestion des collisions)

37 Abstraction Lorsqu’on utilise une structure de données, l’important est de connaître les opérations que l’on peut effectuer sur les données. Un type abstrait de données (TAD, ou ADT en anglais): Description d’une structure de données qui fait abstraction des détails de l’implémentation. Modèle ou type de données abstrait : Écrire des algorithmes indépendamment de la représentation mémoire. Donc définition d'une machine abstraite pour chaque structure de données (Modèle ) avec un ensemble d'opérations Exemple: Créer une liste vide Ajouter un élément (début, fin, milieu) Retirer un élément (début, fin, milieu) Détruire une liste Trier les éléments d’une liste

38 Les tableaux Ensemble d’objets de même type à accès direct
Taille du tableau fixe, n’est pas modifiable, accessible par la valeur Accès aux éléments par tableau[i] Non vérification des bornes si débordement Indices débutant à 0 (en algorithmique 1) Création d’un tableau en 1 étape (2 dans d’autres langages: déclaration et instanciation) Stockage compact Taille fixe, en général Réajustement de taille coûteux en temps Insertion d’élément onéreuse en temps. 1 2 3 9 Indices Tableau de 10 éléments tableau 4 6

39 Copie de tableaux de nombres ou partage
Copie d’un tableau = copie des éléments un à un (la destination doit être créée) 1 2 3 9 T1 5 7 T3 T2 Situation possible en java mais pas en C (T est une constante, utilisation de pointeur)

40 Structures de données en RAM
Allocation mémoire : statique : espace alloué avant l'exécution du programme. dynamique : espace alloué pendant l'exécution. mixte : mélange des deux. Intérêts des pointeurs Gestion de l’espace mémoire en cours d’exécution Modifications de variables passées en paramètres de fonction Représentation de tableaux : accès direct et indexé en C++ d’autres utilisations

41 int* a = NULL;// Initialisation d’un pointeur à “NULL”
int* a=(int*)malloc(3*sizeof(int));//Allocation et assignement a *a free(a); // Désallocation dynamique a *a

42 Liste chaînée : Structures
Tête Noeud p_first p_last nb_elements Node_t p_data p_next List_t Data_t typedef struct LIST { NODE* p_first_node_ ; NODE* p_last_node_ ; int nb_items_ ; } LIST ; typedef struct NODE { struct NODE* next_ ; void* p_item_ ; } NODE ;

43 BOOLEAN check_item( LIST* list, DATA* data ) {
BOOLEAN found = LIST_Owns_Item( list, data ); if( found ) { printf( “Item %d , %c in List”, data->index_, data->value_ ); } return found; List_t* list_create( void ); int list_insert_item( List_t* list, Data_t* item ); Tête Noeud

44 Liste chaînée : Implantation
Choix d'une représentation mémoire et la traduction des opérations du modèle dans cette représentation. Toujours tester la validité d’un pointeur avant de l’utiliser. S’assurer de ne jamais perdre l’adresse d’une zone allouée dynamiquement. Dans un programme, toute allocation par malloc ou calloc doit être suivie d’une désallocation par free.

45 Liste chaînée : Pile et File
Pile, ou Tas (Stack) : structure LIFO void push(Data_t*) Data_t* pop(void) File, ou queue : structure FIFO void push(Data_t*) Data_t* pop(void)

46 Arbres: Structure de données
TreeNode_t p_data p_next Data_t p_first_child p_parent

47 Langage de programmation
Programmer, c’est plus que simplement écrire du code. Comment les langages de programmation diffèrent-ils des langages naturels? Qu’est-ce qu’un bon programmeur? Un programmeur devrait-il connaître plus d’un langages de programmation? Pourquoi étudier les langages de programmation?

48 Structure d’un système informatique
Dispositifs physiques OS Compilateurs Editeurs Applications Interpréteurs Langage machine

49 Niveau de complexité et d’abstraction
Langages de bas niveau (langage machine, assembleur). Langages de haut niveau (les langages les plus utilisés : C, C++, …). Langages de très haut niveau (Prolog, langages spécialises, SQL, …). Au delà des langages de programmation : Environnements de programmation et outils de développement logiciel (J2EE, .NET)

50 Historique des Langages de programmation
1954 FORTRAN (John Backus) 1959 LISP (McCarthy) 1960 COBOL (Grace Hopper) 1960 BASIC (Kemeny, Kurtz) 1971 Pascal (Niklaus Wirth, Kathleen Jensen) 1972 C (Brian W. Kernighan, Dennis Ritchie) 1975 Prolog (Colmerauer et. al.) 1980 Ada 1983 Objective C (ObjC) (Brad Cox) 1983 C++ (Bjarne Stroustrup) 1987 Perl (Larry Wall) 1988 Tcl (John Ousterhout) 1991 Python (Guido van Rossum) 1995 Delphi 1995 Java (Sun Microsystems) 1997 PHP (Rasmus Lerdorf), JavaScript 2001 C# (Microsoft dans le cadre de .NET) 2002 Visual Basic .NET 2003 Delphi.NET

51 Les différent types de langages
Différent langages permettent de résoudre différent problèmes de façon différentes. Une opération peut être exprimée dans différent langages, puis exécuté sur la même machine. Langages à usage général : la plupart des langages que vous connaissez. Langages impératifs : permettent au programmeur d’attribuer des valeurs a des espaces mémoire, afin de décrire explicitement comment résoudre le problème. (Java, C++, Pascal) Langages déclaratifs : permettent au programmeur de déclarer diverse entités et relations. Le programme pourra ensuite utiliser ces declarations pour résoudre le problème. (Prolog, Lisp) Langages spécialises : ex: matlab (mathématiques), Cobol (Gestion), SQL (langage assertionnel pour BD), Perl (langage script).

52 Langages Impératifs Langages Déclaratifs
Programmation procédurale: Le programme est divisé en blocs pouvant contenir des variables locales, ainsi que d’autres blocs. (C, Fortran, Pascal) Programmation orientée-objet: Des objets se rapportant au problème sont définis, avec leurs attributs et leur façon de réagir à différent événements. Le problème est résolu grâce a l’interaction entre ces objets. (Java, C++,…) Langages Déclaratifs Programmation fonctionnelle: Un programme consiste en la déclaration de fonctions. Un appel a une fonction est fait et retournera un élément qui dépendra de la valeur de ses paramètres qui peuvent, eux même, être des appels a des fonctions.(Lisp) Programmation logique: Un programme consiste en la déclaration d’une série d ’axiomes et de règles de déduction, et la présentation d’un théorème à prouver. Le programme répond si le théorème peut être prouvé ou non à partir des déclarations. (Prolog)

53 Critères d’un langage de programmation
Abstraction : abstraction procédurale et l’abstraction des données permettent la généralité des programmes. Absence d’ambiguïtés. Simplicité : C et Pascal sont simple, C++ et Java? Modularité : présence d’outils de modularisation et la capacité d’être incorporé dans un environnement de programmation intégré. Fiabilité : Vérification des types, traitement des exceptions et erreurs, l’absence d’ambiguïtés (et en générale la lisibilité et l’aptitude à l’écriture). Coût associées à l’utilisation du langage : Temps nécessaire au développement (facilité de programmation, disponibilité de code, de librairies et de documentation). Facilité d’implémentation. Portabilité et standardisation.

54 Implémentation de langage de programmation
Processeur de langage : Dispositif (logiciel ou matériel (hardware)) capable d’exécuter des instructions du langage. La traduction est le processus qui transforme un programme d’un langage à un autre, tout en préservant son sens et sa fonctionnalité. Le langage cible peut être directement exécutable sur l’ordinateur, ou (plus souvent) devra à nouveau être traduit en un langage de niveau inférieur. Machine virtuelle : c’est une réalisation logicielle (simulation) d’un processeur de langage. Il est difficile de programmer directement pour le hardware—le hardware est donc généralement « enveloppé » de plusieurs couches logicielles. Une couche peut être partagé par plusieurs processeurs de langage, chacun ayant sa propre machine virtuelle au dessus de cette couche.

55 Modèles d’implémentation
Compilation : Un compilateur a pour rôle de transformer tout programme écrit dans un langage source en un programme réellement exécuté par la machine. Le code résultant sera exécuté plus tard. Interprétation : Divise le programme en petit fragments (représentant des éléments de syntaxe). Une boucle traduit et exécute immédiatement les fragments. On désigne un processeur de langage comme interpréteur s’il ressemble plus à un interpréteur, et comme compilateur, s’il ressemble plus à un compilateur. L’implémentation des langages de programmation utilise souvent un mélange des deux (ex. Java est compilé en « bytecode », puis celui-ci est interprété).

56 Les compilateurs Phases d’un compilateur :
La compilation d'un programme passe par plusieurs phases : Analyse lexicale Analyse syntaxique Analyse sémantique Interprétation ou génération de code Lorsqu'on passe par la phase de génération de code on parle de compilateur. Lorsqu'on passe par la phase d'interprétation on parle d'interpréteur.

57 Analyse lexicale : Analyse microscopique des éléments formant un programme. Ces éléments, appelés unité lexicales, sont les mots réservés du langage, les identificateurs utilisateurs, les caractères spéciaux, les constantes, etc. Un analyseur lexical élimine tout ce qui n'est pas utile pour la phase suivante qui est l'analyse syntaxique. Il ignore ainsi les commentaires et les blancs. Analyse syntaxique : Analyse macroscopique. Derrière tout langage de programmation il y a une grammaire formée de l'ensemble des règles utilisées pour l’écriture des programmes.

58 Analyse sémantique : Donne un sens aux différentes instructions du programme. Facilite l’étape de génération de code ou d'interprétation. Forme interne = Découpage du programme en un ensemble d'opérations élémentaires directement interprétées dans un autre langage de programmation ou traduites en code objet. Génération de code : Consiste à associer à chaque élément de la forme interne l’équivalent en code objet. Interprétation : Consiste à associer à chaque élément de la forme interne l’équivalent dans le langage d'interprétation.

59 Compilation et exécution
Programme source Compilateur Séquence d’unités lexicales Analyse lexicale (scaning) Analyse syntaxique (parsing) Table de symboles Arbre syntaxique Optimisation du code Programme abstrait (code intermédiaire) Analyse sémantique Programme abstrait (optimisé) Chargeur/Éditeur de liens (Loader/Linker) Génération du code Code exécutable (object code) Programme résultant Données d’entré Ordinateur Données de sortie

60 Etapes d'exécution d’un langage compilé : cas C
Compilation Fichier de code d'entête Code objet Edition de liens Autres code objet Librairies Programme exécutable

61 Interprétation+exécution
Compilateur/interpréteur Compilateur: traduire le programme entier une fois pour toutes + plus rapide à l’exécution + sécurité du code source - il faut recompiler à chaque modification Interpréteur: traduire au fur et à mesure les instructions du programme à chaque exécution + exécution instantanée appréciable pour les débutants - exécution lente par rapport à la compilation exemple.c Compilateur fichier source exemple fichier exécutable exécution exemple.bas fichier source Interprétation+exécution