Programmation. fonctionnelle, impérative, logique et orientée objet

Dimension: px
Commencer à balayer dès la page:

Download "Programmation. fonctionnelle, impérative, logique et orientée objet"

Transcription

1 Programmation fonctionnelle, impérative, logique et orientée objet

2 Introduction Les langages de programmation permettent de décrire des calculs de façon plus abstraite qu'un programme machine. Les programmes dans ces langages sont Compilés (transformés en code machine par un compilateur) Ou interprétés (exécutés par un autre programme appelé interpréteur) Un compilateur génère un programme machine pour un processeur donné, dont la sémantique est donnée par le programme source. Un interpréteur lit un programme source et «calcule» sa sémantique directement pour une entrée donnée

3 Compilation (C, Caml, Fortran...) Programme Compilateur (gcc, ocamlopt) Programme machine Le programme compilé est très efficace Entrées Processeur Programme machine Sorties Processeur Interprétation (Lisp) peu efficace Programme + entrées Interpréteur Processeur Sorties

4 Exemple de compilation : factorielle Bytecode Java int k = 1, l = 1; while (k <= i) { l = l * k; k++; } return l; 0: iconst_1 1: istore_2 2: iconst_1 3: istore_3 4: iload_2 5: iload_0 6: if_icmpgt 19 9: iload_3 10: iload_2 11: imul 12: istore_3 13: iinc 2, 1 16: goto 4 19: iload_3 20: ireturn

5 Compilation pour une machine virtuelle (Java, Caml,.Net) Programme Compilateur Processeur Programme bytecode Le programme est portable et moyennement efficace Programme bytecode + entrées Programme bytecode + entrées Machine virtuelle X Processeur X Machine virtuelle Y Sorties Sorties Processeur Y

6 Machine virtuelle Une machine virtuelle est un programme (compilé) qui exécute des programmes (appelés bytecode). En ce sens, c'est un interpréteur. Le langage d'entrée est proche d'un langage machine (d'où le nom de machine virtuelle). Les programmes à exécuter sont obtenus par compilation à partir d'un langage de haut niveau. Il y a autant de versions de la machine virtuelle (compilée) que de machines réelles différentes.

7 Conclusion (de l'introduction) Les compilateurs, interpréteurs, machines virtuelles se chargent : De l'interface avec une machine simple (processeur réel) des performances (en partie) de la portabilité (exécution sur différentes machines) Les langages de programmation offrent : une meilleure expressivité (moyens de structurer les programmes, de raisonner de façon plus abstraite) une spécialisation plus ou moins grande pour des types de problèmes (cas extrême : les langages dédiés) certaines garanties de correction, de sécurité, grâce à des concepts sémantiques forts (typage...)

8 Plan du cours Programmation fonctionnelle Exemples, ordre d'évaluation, exécution par interprétation, Programmation impérative Exemples, portée des identificateurs, gestion de la mémoire, compilation Typage et gestion de la mémoire typage statique (lambda calcul simplement typé), ramasse miettes Programmation orientée objet Exemples, modularité, héritage, liaison dynamique. Programmation logique Exemples, sémantique déclarative et opérationnelle

9 Portée des identificateurs La portée d'une définition (d'un identificateur) dans une expression est la partie de l'expression dans laquelle cette définition est active. En lambda calcul, c'est une notion purement syntaxique (donc pas liée à l'exécution). Dans ( x.e) e', x est lié à e' dans e, mais uniquement pour les occurrences libres de x dans e. De même pour let x = e' in e (les deux expressions sont d'ailleurs équivalentes) La portée est illustrée par la propriété suivante de la relation d'alphaéquivalence : si e ~ e' et e e'' alors il existe e''' tel que e'' ~ e''' et e' e''' Cela signifie qu'on peut voir considérer les lambda termes à alphaéquivalence près.

10 Extensions du lambda calcul On peut enrichir le lambda calcul avec Des entiers et des opérateurs : 0, 1,..., +, en étendant la bêtaréduction : (+ 2) 3 5 Des paires et des destructeurs : (.,.), fst, snd Des constructeurs, pour représenter les types sommes Des définitions de constantes locales : let x = e in e La condition : if e then e else e La récursivité : let rec f x =...f... Tous ces ajouts sont représentables en lambda calcul pur (cependant pour la récursivité, la terminaison dépend de l'ordre de réduction)

11 Programmation fonctionnelle

12 La programmation fonctionnelle pure se contente du lambdacalcul plus ou moins étendu (exemple : le langage Haskell). Les lambda termes clos représentent des fonctions au sens mathématique. Le résultat ne change pas d'un appel à l'autre, il ne dépend pas d'un quelconque «état» ou «contexte» autre que les arguments. Propriété de transparence référentielle : On peut toujours remplacer une expression par sa valeur. En particulier, une application de fonction peut être remplacée par son résultat, ou (par transitivité) par l'appel d'une autre fonction «équivalente» à la première. Intuitivement, seul le résultat compte (pas d'effets de bord).

13 Les fonctions sont des valeurs comme les autres : au cours de l'exécution on peut les créer, les appliquer, les retourner en résultat, les passer en argument d'autres fonctions. Les données ont le plus souvent une structure récursive (listes, arbres) ainsi que les fonctions qui les manipulent.

14 Bêta réduction et ordre de réduction Bêta réduction : réduction non déterministe la substitution e[e ' / x ]est licite x.e e' e [e' / x] e e' x.e x.e' e e' e e' ' e' e' ' e e' e ' ' e e' ' e' Caml : les arguments d'abord (non spécifié officiellement) x.e e' e[e ' / x] x.e est une forme normale e e' e e' ' e' e' ' e e' e ' ' e e' ' e' prioritaire par rapport aux deux autres règles Évaluation paresseuse (Haskell) : x.e e' e[e ' / x] remplacement sans recopie! x.e est une forme normale e e' e e' ' e' e' '

15 Ordre de réduction L'ordre d'évaluation n'a d'importance que pour : La terminaison (c'est au programmeur d'écrire des programmes qui terminent pour l'ordre considéré, mais cet ordre importe rarement) L'efficacité (certains chemins sont moins coûteux que d'autres) Les programmes impératifs (références, tableaux, entrées sorties). Évaluation en caml : opérandes d'abord Toute lambda abstraction est une valeur (ou forme normale) et n'est donc pas réduite (pensez aux effets de bord, ex : fun x > y := 0) Pour réduire (e e'), on réduit e' jusqu'à obtenir une lambdaabstraction, puis on réduit e, puis l'expression globale. Cette réduction est plus faible que la bêta réduction, (on ne réduit pas sous les lambda ) mais plus naturelle s'il y a des effets de bord. Évaluation paresseuse (en Haskell par exemple) : on ne réduit que les expressions indispensables, et au maximum une fois.

16 En caml : ( x. y.(+ x x)) (+ 1 1) (+ 2 2) ( x. y.(+ x x)) (+ 1 1) 4 ( x. y.(+ x x)) 2 4 ( y.(+ 2 2)) Évaluation paresseuse : (appel par nom) ( x. y.(+ x x)) (+ 1 1) (+ 2 2) ( y.+ ((+ 1 1) (+ 1 1))) (+ 2 2) on ne duplique pas réellement (+ 1 1) (+ 1 1) n'est jamais évalué

17 Un interpréteur simplissime Cette fonction évalue un terme clos (c'est à dire sans variable libre). let rec eval = function e e' let e'r = eval e' in let x.e'' = eval e in (* Sinon, on est bloqué *) eval e''[e'r / x] e e (* c'est une valeur *)

18 Pour éviter de faire des remplacements coûteux, on préfère évaluer un terme dans un contexte, qui associe des termes à des identificateurs : let rec eval c = function e e' let e'r = eval c e' in x c(x) e e let x.e'' = eval c e in eval [e'r / x] :: c e'' où [e'r / x] :: c est le contexte c enrichi par l'association de x e'r. Tout identificateur x déjà défini dans c est masqué temporairement (liaison statique). Remarque historique : si au lieu de masquer x, on le remplace, on obtient ce qui s'appelle la liaison dynamique (présente en Lisp). Ce principe contreintuitif remet en cause les bonnes propriétés du lambda calcul (confluence, renommage, etc.) et n'est plus utilisé (sauf pour les méthodes dans les langages à objets, dans un cadre bien défini).

19 Programmation impérative

20 L'impératif arrive avec les variables (pointeurs) et les effets de bord type 'a ref, val ref,!, := Les structures de contrôle permettent de structurer le flot d'exécution de façon intuitive. e ; e' while e do e done for x = e to e do e done En fait, on pourrait les programmer de façon récursive, connaissant l'ordre d'évaluation de Caml Les types de données associés à la programmation impérative sont les tableaux et les structures modifiables en place (à champs mutables). Les fonctions ne sont pas des données dans un langage impératif. Certaines fonctions ne retournent rien et ne sont utiles que par leurs effets de bord. On les appelle des procédures.

21 Structures de contrôle Le contrôle bas niveau de l'exécution (goto, jump_if_zero), n'est plus utilisé pour programmer (sauf dans certaines applications très spécifiques (code optimisé pour des pilotes...) et aussi par certains vieux physiciens... En revanche, les return, break, continue de Java peuvent simplifier certains algorithmes. Les exceptions permettent également de remonter brutalement dans la structure de contrôle, mais elles permettent de plus de fournir une valeur exceptionnelle, qu'on peut utiliser ensuite.

22 Portée En caml, les références et les tableaux sont des constantes comme les autres (sauf que l'opération! ne renvoie pas toujours le même résultat). La portée est donc toujours définie syntaxiquement comme l'expression sous le lambda ou le let... in... En C (et dans les autres langages impératifs), on a un tout petit peu moins de liberté : la portée peut être globale (tout le programme) locale à une fonction, à une boucle ou à un bloc (l'équivalent du let... in... : {int x ;...}) le masquage d'une déclaration par une autre est restreint. Du point de vue de la programmation, il convient de toujours donner aux déclarations la plus petite portée possible.

23 Compilation des langages impératifs En simplifiant à l'extrême (on oublie les données et les optimisations) la compilation consiste à transformer les structures de contrôle de haut niveau en branchements élémentaires compréhensibles par le processeur : While condition do corps i0 : condition... : condition i1 : jump_if_zero i2 i1+1 : corps... : corps i2 1 : goto i1 i2 : suite Les tableaux sont représentés par des adresses contiguës et on calcule l'adresse d'une case en ajoutant son indice à l'adresse du tableau. De même pour les types structures.

24 Typage et gestion de la mémoire

25 Lambda calcul simplement typé (présentation informelle) Les types : types de base (int, bool) ou variables de types types flèches : si t, t' sont des types, on forme t t' Les lambda termes typés : variables (x, y) applications : e e' où e, e' sont des lambda termes typés abstraction : x:t.e où t est un type et e un lambda terme typé Jugements de type : Г e : t où e est un terme, t un type et Г un contexte. (voir règles au tableau)

26 Sémantique Typage : les règles suivantes définissent le jugement x : t (x est de type t). x :t x :t, x :t e :t ' x : t.e: t t ' e :t t ' e ': t ee ': t ' Réduction : On choisi les mêmes règles que la bêta réduction, ou bien une stratégie d'évaluation particulière. la substitution e[e ' / x ]est licite x : t.e e' e[e ' / x ] e e' x : t.e x : t. e' e e' e e' ' e' e' ' e e' e ' ' e e' ' e' Aucun programme bien typé ne se bloque

27 Well typed programs never go wrong Les types assurent une certaine cohérence aux programmes. Dans un lambda calcul enrichi, cela se traduit par un théorème sur la réduction : Un programme bien typé ne peut se réduire qu'en un programme bien typé (préservation). Un programme bien typé ne peut être bloqué (progrès). Par exemple, les programmes (1 2), (plus true 0) et (1 := 2) sont bloqués. Dans la réalité, le bloquage se transforme en des opérations absurdes consistant confondre des entiers et des adresses en mémoire, et inventer des adresses qui ne correspondent à rien. Le typage peut aussi servir à prévenir les accès non autorisés à un système. La libération explicite de la mémoire (free) si elle est faite trop tôt, et la conversion de type (cast) cassent le système de types (formellement, la préservation). D'où une interdépendance avec le garbage collector.

28 D'après la propriété de préservation, il suffit de vérifier le typage avant exécution, et on peut l'oublier ensuite : le typage est statique. Parfois, dans les vrais langages, le typage n'est pas entièrement statique : on doit mettre des contraintes explicites qui sont vérifiées à l'exécution (ce qui est coûteux car il faut garder et manipuler des types à l'exécution). C'est le cas en Java (à nuancer avec Java 1.5 et ses classes génériques) : LinkedList s = new LinkedList(); s.add(new Element()); Element e = (Element) (s.getfirst()); Une alternative : les types génériques pour les fonctions et les structures de données. Ces types sont beaucoup plus compliqués à vérifier, surtout si on veut faire de l'inférence. type 'a list = Nil Cons of 'a * 'a list List.map : 'a 'b ('a > 'b) > 'a list > 'b list

29 Systèmes de types De nombreux langages possèdent : Des types de base : int, char, string, bool Des types pointeurs, tableaux, fonctions La possibilité de définir de nouveaux types produits (structures) Un système de types est le plus utile lorsqu'il est inviolable. Le langage C au contraire possède un système de types non sûr (pour de raisons de performances et de simplicité). Java, Caml, Haskell ont des systèmes de types sûrs. Lisp est un langage non typé.

30 Gestion de la mémoire Reprenons l'interpréteur avec contexte du lambda calcul : let rec eval c = function... x eval c (assoc c x)... Lorsqu'on doit évaluer x dans un environnement c, on ne va pas recopier la valeur associée à x dans le c : on se contente de retourner la même zone mémoire, en espérant qu'elle ne sera pas effacée... En effet, dans (( a.a)( b.b))(( c.c)( d.d)), il faut garder la valeur de c, à savoir ( d.d), même après l'avoir dépilée du contexte. En revanche, à la fin, la valeur de a n'a plus d'intérêt.

31 Le ramasse miettes La durée de vie d'un objet peut donc dépasser la portée des identificateur auxquels il peut être associé (il peut y en avoir plusieurs) lors de l'exécution. De plus, on ne peut pas décider statiquement si à tel point de programme un objet peut être libéré ou non (conséquence du théorème de Rice). On utilise donc un garbage collector : un programme qui, de temps en temps au cours de l'exécution du programme principal, regarde quels objets sont devenus inaccessibles, et les supprime pour récupérer de la mémoire. On sait que dans un langage muni d'un système de types sûr (propriété de préservation définie plus haut), un objet inaccessible l'est définitivement.

32 Programmation orientée objet

33 Objectif : associer données et traitements Les objets sont des valeurs qui contiennent à la fois un état (des données mutables) des méthodes qui font référence à l'état (de cet objet). On veut cacher les détails du fonctionnement interne (encapsulation) class Counter { private int i; public Counter {i = 0;} public int get() {return i;} public void incr() {i++;} } Une classe définit à la fois Un type d'objets Des moyens de construire des objets de ce type Leur comportement, de façon générique, au travers des méthodes.

34 Les éléments d'un langage objet Objets et classes : représentation de types de données abstraits Les objets : des super «records» Les classes : des modèles d'objets Héritage d'interfaces d'implémentation La liaison dynamique et la généricité et l'héritage

35 Composition d'un objet Des attributs d'instance (comme les champs d'un enregistrement) int n = 10 bool b = true,... Object x =... De méthodes d'instance (qui peuvent accéder aux attributs) void changenumero(int m) {n = m} (affectation) bool pair() {return (n mod 2 == 0);} bool greater(object o) {return (n >= o.n);} bool equals(object o) {return (greater(o) && o.equals(this));} int factorielle(int i) {if (i == 0) return 1; else return i*factorielle(i 1);} L'idée est de rapprocher les données et leurs opérations associées.

36 Composition d'une classe Une classe est un type (comme un type enregistrement) types des attributs d'instance : int n, bool b, Object o,... signatures des méthodes void changenumero(int), bool pair(),... Une classe est un modèle initialisation des attributs par un constructeur MaClasse(n, b, o) {this.n = n, this.b = this.b, this.o = o} corps des méthodes (les attributs sont différents pour chaque objet) void changenumero(int m) {n = m;}

37 Définition En Java Utilisation class Counter = { } int x; // un attribut Counter(x) {this.x = x;} // un constructeur Counter() {x = 0;} // un autre constructeur int value() {return x;} // une méthode void incr(int i) {x = x + i;} // une autre Counter c1, c2; c1 = new Counter(3); c2 = new Counter(4); c1.incr(2); int v; v = c2.value();... Remarques : Les méthodes sont implicitement mutuellement récursives this désigne l'objet «courant» surcharge : dans une même classe, deux méthodes peuvent avoir le même nom, à condition d'être distinguables par les types de leurs arguments. En Java, tout objet est construit à partir d'une classe, qui est aussi son type.

38 Champs et méthodes d'instance et de classe Les attributs et méthodes «ordinaires» sont dits d'instance class C {... int x;...} : un attribut x par objet de classe C class C {... int m();...} : une méthode m par objet de classe C Les attributs et méthodes de classe (appelés statiques en Java) existent en un seul exemplaire pour toute la classe. class C {... static int x;...} : un seul x pour toute la classe class C {... static int m();...} : une seule méthode m

39 Objets et modules sont bien adaptés à la description de types de données abstraits (ADT) : piles, arbres, tables, etc.. Dans la version orientée objet, toutefois, une version modifiable est plus souvent utilisée, pour correspondre au caractère impératif des langages à objets en général. module List = struct type 'a t val nil : 'a t val cons : 'a > 'a t > 'a t val head : 'a t > 'a } module List = struct type 'a t val empty : unit > 'a t val add : 'a > 'a t > unit val head : 'a t > 'a } modules class List { public static nil =... public List cons(object o) {...} public Object head() {...} } fonctionnel objets class List { impératif public List () {...} public void add(object o) {...} public Object head() {...} }

40 Liaison dynamique Que se passe t il lorsqu'on redéfinit une méthode qui était utilisée par une autre? class Counter { int x; void incr(int i) {x = x + i;} void incr1() {incr(1);} } class CounterModulo extends Counter { void incr(int i) {x = x + i % 2;} } Counter c = new CounterModulo(); c.incr1() ; c.incr1(); La liaison est dynamique : on ne connaît la méthode incr à appeler qu'au moment de l'exécution : c'est celle qui est définie dans la classe de l'objet c, c'est à dire CounterModulo. Autre exemple : Counter [] counters = {new Counter(), new CounterModulo()}; for (i = 0 ; i < 2 ; i++) counters[i].incr(); Il est impossible en général (indécidable), de savoir quelle méthode sera appelée effectivement.

41 Compatibilité et liaison dynamique Des objets qui partagent un certain nombre de méthodes (même nom, même signature) ont une certaine compatibilité : class List {... public void add(object o) {...} } class Set {... public void add(object o) {...} } L'intérêt des objets est qu'on peut appeler la méthode add d'un objet sans connaître son type exact (ce serait impossible avec des données simples et des fonctions add associées). Il s'agit d'une liaison dynamique (contrôlée).

42 Héritage Une interface en regroupe des signatures de méthodes qu'un objet doit posséder pour implémenter cette interface : c'est la notion de type pour les objets. L'héritage d'interface (sous typage) est un moyen d'étendre une interface en ajoutant des méthodes ; les objets qui implémentent une sous interface sont alors compatibles avec la super interface : interface Collection { public void add(object o); public bool isempty(); } interface List extends Collection { public Object get(int Index); }

43 Héritage L'héritage d'implémentation (simple) permet d'étendre une classe en une autre en lui ajoutant des attributs et des méthodes. Il permet le partage de méthodes entre différentes classes : class Counter { int x; void incr(int i) {x = x + i;} } class RazCounter extends Counter { void raz() {x = 0;} } class ProgramCounter extends Counter { Instruction [] prog; Instruction next() {return prog[x];} } Une classe peut utiliser les méthodes et attributs de sa super classe class UnCounter extends Counter { void decr(int i) {incr( i);} } Une classe peut redéfinir les méthodes de sa super classe class CounterModulo extends Counter { void incr(int i) {x = x + i % 2;} }

44 Héritage et liaison dynamique L'héritage d'implémentation est un bon moyen de réutiliser du code : une méthode héritée est partagée avec la super classe (La liaison dynamique joue un rôle important). class Collection { public abstract void add(object o); public void addall(collection c) { for(...) add(...); } } class List extends Collection { public void add(object o) {...} } class Set extends Collection { public void add(object o) {...} }

45 Compilation et exécution Contrairement au cas des langages impératifs, un appel de méthode dans un langage à objets ne peut pas toujours être résolu à la compilation (exemple de add). Il faut donc, à l'exécution, chercher la bonne méthode, qui peut se trouver dans la classe de l'objet, ou dans une super classe. On peut considérer du point de vue du langage que chaque objet possède ses propres méthodes (celles ci sont donc dupliquées autant de fois qu'il y a d'objets différents). Dans une implémentation efficace néanmoins, on ne crée qu'une seule fonction pour une classe et une méthode données, et l'objet this devient un argument supplémentaire.

46 Programmation logique

47 Programmation logique

48 Programmes logiques Une clause de Horn est une disjonction de formules atomiques dont au plus une est positive : p(f(x)) q r(f(x), g(x, f(x))) Une telle formule est logiquement équivalente à : p(f(x)) q r(f(x), g(x, f(x))) Et on la note en Prolog : p(f(x)) :- q, r(f(x),g(x, f(x))) Un programme logique est un ensemble fini de clauses de Horn.

49 Exemples est_triee(cons(x, cons(y, L))) : inf(x, Y), est_triee(cons(y, L)). est_triee(nil). est_triee(cons(x, nil)). Pair(0). impair(s(x)) : pair(x). pair(s(x)) : impair(x). plus(x, 0, X). plus(x, s(y), s(z)) : plus(x, Y, Z).

50 La négation Il n'y a pas de vraie négation en prolog (impossible à définir avec des clauses de Horn). On peut cependant y parvenir en essayant de prouver un but et en vérifiant qu'il n'y a pas de solution. C'est la négation par l'échec. Évidemment, le prédicat de départ doit être fait pour terminer même s'il n'y a pas de solution.

51 Exécution Pour exécuter un programme Prolog, on se donne un but, qui est une conjonction de formules atomiques (non closes) : plus(s(0), s(s(0)), X) Ou encore pair(x) L'interpréteur retourne alors une (ou des) substitution(s) qui rend(ent) ce but prouvable (s'il en existe). X = s(s(s(0))) X = 0, X = 2, X = 4,...

52 Sémantique déclarative Un programme logique définit une théorie (l'ensemble des conséquences des formules du programme). Pour un but donné, un programme logique peut boucler, ou bien s'arrêter. Dans les deux cas, il peut rendre zéro ou plusieurs substitutions. Toute substitution rendue par le programme (même s'il boucle après) fait du but une conséquence de la théorie. Si le programme termine, alors toutes les conséquences qui ont la forme du but ont été énumérées.

53 Sémantique opérationnelle Prolog procède par résolution linéaire directe pour les clauses de Horn. C'est une méthode de preuve correcte et complète, d'où les deux propriétés de la sémantique déclarative. Principe : On commence par chercher la première clause du programme dont la tête s'unifie avec le but courant. On applique alors la substitution obtenue à la queue de la clause On cherche alors à prouver (de gauche à droite) les prémices de cette clause (qui deviennent tour à tour le but courant). Lorsqu'on est bloqué dans une impasse, on revient en arrière, pour essayer une autre clause. Ce faisant, on construit (par les unifications successives) une substitution qui rend le but prouvable.

54 Intérêt et défauts Prolog est un langage adapté à la recherche de solutions (Sudoku?), pour faire de l'inférence de type, etc. Les prédicats du programme jouent le rôle de fonctions, qu'on peut appeler de différentes façons : plus peut servir pour l'addition et la soustraction, selon l'instanciation des paramètres. L'impératif s'intègre plutôt mal (car l'ordre d'évaluation est difficile à prévoir), ce qui peut poser problème pour les entréessorties et l'interface avec d'autres langages. L'absence de déclaration préalable des symboles de fonctions et de prédicats est une source importante d'erreurs (Il existe des versions typées de Prolog cependant).

55 Conclusion : les défis de la programmation aujourd'hui La programmation parallèle, qu'on n'a pas abordée, est souvent très délicate et suscite également à elle seule de nombreux paradigmes de programmation (passage de messages ou partage de données, etc.). Les besoins sont croissants (grappes de processeurs, processeurs à plusieurs coeurs).

56 Conclusion : les défis de la programmation aujourd'hui Le génie logiciel : programming in the large. Écrire de gros programmes pose depuis des décennies des problèmes fondamentalement différents : organisation, évolution (maintenance), réutilisation La maîtrise de la programmation orientée objet, générique, par composants, par aspects... aide à résoudre ces problèmes.

57 Conclusion : les défis de la programmation aujourd'hui La sûreté de fonctionnement des logiciels est loin d'être une question résolue. Des techniques élaborées de test, d'analyse automatique, voire de preuve formelle avec un assistant, sont autant de domaines de recherches. Bien entendu, les paradigmes, et mêmes les langages de programmation utilisés influencent beaucoup les possibilités.

58 Un peu de lambda calcul

59 Syntaxe du lambda calcul (on ajoutera des parenthèses quand c'est nécessaire pour lever les ambiguïtés) e = x (identificateur) x.e (lambda abstraction) ee (application) Exemple : x. y.(xy) (en caml : fun x > fun y > x y)

60 Occurrences libres Dans ( x.x) x, le second x est une occurrence liée de l'identificateur x ; le troisième est une occurrence libre. Remplacement On note e[e' / x] le terme obtenu en remplaçant simultanément toutes les occurrences libres de x par e' dans e Exemple : ( x.x)x [( y.yy) / x] = ( x.x)( y.yy) Une substitution est licite si aucune variable libre du terme e' n'est capturée par un lambda de e Exemple : ( x.y) [x / y] n'est pas licite.

61 Alpha équivalence (renommage) si y n'a pas d'occurrence libre dans e alors x.e ~ y.e[y / x] si e ~ e' alors x.e ~ x.e' si f ~ f' et e ~ e' alors f e ~ f' e' on prend la fermeture symétrique réflexive transitive L'alpha équivalence permet de renommer un identificateur, en évitant le phénomène de capture : x. y.xy est équivalent à x. z.xz, mais pas à x. x.xx (car x a une occurrence libre dans xy)

62 Bêta réduction Exemple : si la substitution e[e' / x] est licite alors ( x.e) e' e[e' / x] si e e' alors x.e x.e' si e e' alors e e'' e' e'' et e'' e e'' e' (( x. y.xy) ( x.x)) t ( y.( x.x)y) t ( x.x)t t ou bien ( y.( x.x)y) t ( y.y)t t Confluence : L'ordre de réduction ne change pas le résultat : il ne peut y avoir qu'une seule forme irréductible d'un lambda terme (mais parfois certains chemins peuvent terminer et d'autres non). Le lambda terme suivant se réduit indéfiniment. ( x.xx)( x.xx) ( x.xx)( x.xx)...

Pour signifier qu'une classe fille hérite d'une classe mère, on utilise le mot clé extends class fille extends mère

Pour signifier qu'une classe fille hérite d'une classe mère, on utilise le mot clé extends class fille extends mère L'héritage et le polymorphisme en Java Pour signifier qu'une classe fille hérite d'une classe mère, on utilise le mot clé extends class fille extends mère En java, toutes les classes sont dérivée de la

Plus en détail

TP n 2 Concepts de la programmation Objets Master 1 mention IL, semestre 2 Le type Abstrait Pile

TP n 2 Concepts de la programmation Objets Master 1 mention IL, semestre 2 Le type Abstrait Pile TP n 2 Concepts de la programmation Objets Master 1 mention IL, semestre 2 Le type Abstrait Pile Dans ce TP, vous apprendrez à définir le type abstrait Pile, à le programmer en Java à l aide d une interface

Plus en détail

Évaluation et implémentation des langages

Évaluation et implémentation des langages Évaluation et implémentation des langages Les langages de programmation et le processus de programmation Critères de conception et d évaluation des langages de programmation Les fondations de l implémentation

Plus en détail

Génération de code : langages objets Gestion mémoire 2 novembre 2011

Génération de code : langages objets Gestion mémoire 2 novembre 2011 Génération de code : langages objets Gestion mémoire 2 novembre 2011 1 Compilation d un langage objet Représentation des classes et des objets Héritage multiple Appartenance à une classe 2 Environnement

Plus en détail

Conception et Développement Orientés Objets Cours 1 : Introduction. 2 Les paradigmes de programmation. 3 Les concepts de la programmation objet

Conception et Développement Orientés Objets Cours 1 : Introduction. 2 Les paradigmes de programmation. 3 Les concepts de la programmation objet CNAM UV 19357 Année 2003-2004 David Delahaye David.Delahaye@cnam.fr Conception et Développement Orientés Objets Cours 1 : Introduction 1 Présentation de la valeur Ce cours s adresse à toute personne ayant

Plus en détail

Analyse statique de programmes Typage et analyse statique au sein de Java

Analyse statique de programmes Typage et analyse statique au sein de Java Analyse statique de programmes Typage et analyse statique au sein de Java Master Professionnel Informatique spécialité FSIL/FSI Jean-Marc Talbot jean-marc.talbot@lif.univ-mrs.fr Aix-Marseille Université

Plus en détail

6.1 Une classe simple pour représenter des comptes bancaires

6.1 Une classe simple pour représenter des comptes bancaires Chapitre 6 Héritage Ce chapitre du cours traite de concepts relatifs à la programmation objet (hiérarchie de classe, héritage, extension, masquage) et sera illustré par un exemple de représentation de

Plus en détail

Cours 1 : La compilation

Cours 1 : La compilation /38 Interprétation des programmes Cours 1 : La compilation Yann Régis-Gianas yrg@pps.univ-paris-diderot.fr PPS - Université Denis Diderot Paris 7 2/38 Qu est-ce que la compilation? Vous avez tous déjà

Plus en détail

Eléments de syntaxe du langage Java

Eléments de syntaxe du langage Java c jan. 2014, v3.0 Java Eléments de syntaxe du langage Java Sébastien Jean Le but de ce document est de présenter es éléments de syntaxe du langage Java : les types primitifs, les opérateurs arithmétiques

Plus en détail

Mise à niveau en Java

Mise à niveau en Java Mise à niveau en Java Cours 1 Stéphane Airiau Université Paris-Dauphine Stéphane Airiau (Université Paris-Dauphine) - Java Cours 1 1 Aujourd hui Eléments de base Variables, opérateurs, type d une expression

Plus en détail

Généralités sur le Langage Java et éléments syntaxiques.

Généralités sur le Langage Java et éléments syntaxiques. Généralités sur le Langage Java et éléments syntaxiques. Généralités sur le Langage Java et éléments syntaxiques....1 Introduction...1 Genéralité sur le langage Java....1 Syntaxe de base du Langage...

Plus en détail

Java Licence professionnelle CISI 2009-2010

Java Licence professionnelle CISI 2009-2010 Java Licence professionnelle CISI 2009-2010 Cours 10 : Type générique (c) http://manu.e3b.org/java/tutoriels/avance/generique.pdf 1 Introduction La programmation générique - nouveauté la plus significative

Plus en détail

Programmation récursive

Programmation récursive Année 2004-2005 F. Lévy IUT De Villetaneuse Dép t informatique Cours d'algorithmique 2 éme Année Cours 8 Programmation récursive 1. Qu'est-ce que la programmation récursive Définition : la programmation

Plus en détail

Programmation objet. Objectifs - maitriser le paradigme de Programmation Orientée Objet - savoir utiliser efficacement et pleinement le langage Java

Programmation objet. Objectifs - maitriser le paradigme de Programmation Orientée Objet - savoir utiliser efficacement et pleinement le langage Java Programmation objet Objectifs - maitriser le paradigme de Programmation Orientée Objet - savoir utiliser efficacement et pleinement le langage Java - notions de bases d'algorithmique - bases syntaxiques

Plus en détail

Héritage presque multiple en Java (1/2)

Héritage presque multiple en Java (1/2) Héritage presque multiple en Java (1/2) Utiliser deux classes ou plus dans la définition d'une nouvelle classe peut se faire par composition. class Etudiant{ int numero; Diplome d; float passeexamen(examen

Plus en détail

Chapitre 2. Classes et objets

Chapitre 2. Classes et objets Chapitre 2: Classes et Objets 1/10 Chapitre 2 Classes et objets Chapitre 2: Classes et Objets 2/10 Approche Orientée Objet Idée de base de A.O.O. repose sur l'observation de la façon dont nous procédons

Plus en détail

Rappel. Analyse de Données Structurées - Cours 12. Un langage avec des déclaration locales. Exemple d'un programme

Rappel. Analyse de Données Structurées - Cours 12. Un langage avec des déclaration locales. Exemple d'un programme Rappel Ralf Treinen Université Paris Diderot UFR Informatique Laboratoire Preuves, Programmes et Systèmes treinen@pps.univ-paris-diderot.fr 6 mai 2015 Jusqu'à maintenant : un petit langage de programmation

Plus en détail

Cours 1 : Introduction Générale + Objet I

Cours 1 : Introduction Générale + Objet I Organisation du cours Équipe pédagogique DUT Informatique S3 - Programmation Java Jean-Claude MARTIN MARTIN@LIMSI.FR Cours 1 : Introduction Générale + Objet I Jean-Claude MARTIN (Responsable, Cours, TD

Plus en détail

Paradigme de programmation Impératif

Paradigme de programmation Impératif Paradigme de programmation Impératif La programmation impérative est caractérisée par, la programmation avec un état et des commandes qui modifient l état : Programmation impérative Procédurale = Programmation

Plus en détail

Chapitre 6 Héritage en Java

Chapitre 6 Héritage en Java Chapitre 6: Héritage 1/12 Chapitre 6 Héritage en Java Chapitre 6: Héritage 2/12 1. Généralités L'héritage est le troisième des paradigmes de la programmation orientée objet (le 1 er étant l'encapsulation,

Plus en détail

λ-calcul et typage Qu est-ce qu une fonction?

λ-calcul et typage Qu est-ce qu une fonction? λ-calcul et typage Nicolas Barnier, Pascal Brisset ENAC Avril 2009 Nicolas Barnier, Pascal Brisset (ENAC) λ-calcul et typage Avril 2009 1 / 1 Qu est-ce qu une fonction? Classiquement Pas de notation uniforme/standard

Plus en détail

INITIATION AU LANGAGE C SUR PIC DE MICROSHIP

INITIATION AU LANGAGE C SUR PIC DE MICROSHIP COURS PROGRAMMATION INITIATION AU LANGAGE C SUR MICROCONTROLEUR PIC page 1 / 7 INITIATION AU LANGAGE C SUR PIC DE MICROSHIP I. Historique du langage C 1972 : naissance du C dans les laboratoires BELL par

Plus en détail

Résumé Introduction Programmation Java

Résumé Introduction Programmation Java Résumé Introduction Programmation Java Concepts Un programme : séquence, test conditionnel, boucles. Objets : Les objets Java modélisent les objets d un problème donné Classe : Les objets sont crées à

Plus en détail

Vérification formelle de la plate-forme Java Card

Vérification formelle de la plate-forme Java Card Vérification formelle de la plate-forme Java Card Thèse de doctorat Guillaume Dufay INRIA Sophia Antipolis Cartes à puce intelligentes Java Card : Environnement de programmation dédié. Dernières générations

Plus en détail

Compilation. Vb. Analyse sémantique statique Analyse de nom et analyse de type

Compilation. Vb. Analyse sémantique statique Analyse de nom et analyse de type Université de Nice - Sophia Antipolis Licence 3 Informatique 2012-2013 1/32 Compilation Vb. Analyse sémantique statique Analyse de nom et analyse de type Jacques Farré Jacques.Farre@unice.fr Université

Plus en détail

xkcd Le langage Python La GUI tkinter Christian Nguyen Département d informatique Université de Toulon et du Var 2012-2013

xkcd Le langage Python La GUI tkinter Christian Nguyen Département d informatique Université de Toulon et du Var 2012-2013 La GUI tkinter Département d informatique Université de Toulon et du Var 2012-2013 Présentation Python est né en 1990, son concepteur est De Guido Van Rossum(Pays Bas). Il présente les caractéristiques

Plus en détail

Analyse Statique de Programmes

Analyse Statique de Programmes Analyse statique et application. Typage. Analyse de flots de données. Exemples de transformations simples de programmes au niveau source. Prépa Agreg de Maths, option Info - ENS Cachan-Bretagne Thomas

Plus en détail

Programmation fonctionnelle avec OCaml

Programmation fonctionnelle avec OCaml Programmation fonctionnelle avec OCaml 1ère séance, 19 février 2015 6 séances de 1h30 de cours et 3h de TP 3 projets avec soutenance D autres transparents sont disponibles avec vidéo (intranet) Samuel

Plus en détail

Evaluation paresseuse et structure fonctionnelles persistantes efficaces. La stratégie d évaluation dans les langages fonctionnels

Evaluation paresseuse et structure fonctionnelles persistantes efficaces. La stratégie d évaluation dans les langages fonctionnels Evaluation paresseuse et structure fonctionnelles persistantes efficaces Evaluation stricte et evaluation paresseuse Les Queues de la sémaine passée : efficacité ou persistance? Les Queues révisitéés :

Plus en détail

Avant de programmer en Java DOS Set Path=C:\JDK\bin Path=C:\JDK\bin C:\JDK\bin Set Path=%Path%;C:\JDK\bin C:\JDK\bin C:\JDK\

Avant de programmer en Java DOS Set Path=C:\JDK\bin Path=C:\JDK\bin C:\JDK\bin Set Path=%Path%;C:\JDK\bin C:\JDK\bin C:\JDK\ Exercices corrigés de programmation OO Java Préparés par : Mlle Imene Sghaier Année Académique : 2006-2007 Premiers Pas I. Avant de programmer en Java Le JDK de Sun (Java Development Kit) est l outil essentiel

Plus en détail

Cours intensif Java. 1er cours: de C à Java. Enrica DUCHI LIAFA, Paris 7. Septembre 2009. Enrica.Duchi@liafa.jussieu.fr

Cours intensif Java. 1er cours: de C à Java. Enrica DUCHI LIAFA, Paris 7. Septembre 2009. Enrica.Duchi@liafa.jussieu.fr . Cours intensif Java 1er cours: de C à Java Septembre 2009 Enrica DUCHI LIAFA, Paris 7 Enrica.Duchi@liafa.jussieu.fr LANGAGES DE PROGRAMMATION Pour exécuter un algorithme sur un ordinateur il faut le

Plus en détail

C ellules. Gestion et récupération automatique de mémoire. Principes des lang. de progr. INE 11. Allocation dynamique de mémoire.

C ellules. Gestion et récupération automatique de mémoire. Principes des lang. de progr. INE 11. Allocation dynamique de mémoire. Principes des lang. de progr. INE 11 Michel Mauny ENSTA ParisTech Prénom.Nom@ensta.fr Michel Mauny (ENSTA ParisTech) INE 11 Prénom.Nom@ensta.fr 1 / 37 Gestion et récupération automatique de mémoire lanage

Plus en détail

Programmation Par Objets et Langage Java

Programmation Par Objets et Langage Java Programmation Par Objets et Langage Java Partie I. Fondement de la POO (Modularité/Abstraction) Najib Tounsi Ecole Mohammadia d'ingénieurs, Rabat Année 2011/2012 1ère année Génie Informatique http://www.emi.ac.ma/ntounsi/cours/java/poojavapart-1.pdf

Plus en détail

Chapitre VI- La validation de la composition.

Chapitre VI- La validation de la composition. Chapitre VI- La validation de la composition. Objectifs du chapitre : Expliquer les conséquences de l utilisation de règles de typage souples dans SEP. Présenter le mécanisme de validation des connexions

Plus en détail

Langage Élémentaire Algorithmique Spécifications du langage

Langage Élémentaire Algorithmique Spécifications du langage Langage Élémentaire Algorithmique Spécifications du langage Lionel Clément Version provisoire Novembre 2012 Le but de ce projet est de livrer un compilateur pour un langage élémentaire algorithmique (Léa).

Plus en détail

Programmation Avancée - Prolog

Programmation Avancée - Prolog Programmation Avancée - Prolog N. Prcovic Programmation Avancée - Prolog p.1/26 Introduction La programmation logique est une forme particulière de programmation déclarative. La programmation déclarative

Plus en détail

1.Programmation en Java : notions de base, orienté objet et héritage

1.Programmation en Java : notions de base, orienté objet et héritage Travaux pratique de Méthodologie et Langage de Programmation,, TP1 1 1.Programmation en Java : notions de base, orienté objet et héritage Cette séance de TP a pour objectif d'introduire à la programmation

Plus en détail

Programmation fonctionnelle

Programmation fonctionnelle Programmation fonctionnelle Cours + exos corrigés Éric Violard Maître de conférences HDR à l université de Strasbourg Au terme de ce projet, je souhaite dédier ce livre à ma fille Julie et à son bonheur

Plus en détail

Types et langages de programmation. Algorithmique et Programmation Unisciel/K.Zampieri

Types et langages de programmation. Algorithmique et Programmation Unisciel/K.Zampieri Types et langages de programmation Algorithmique et Programmation Unisciel/K.Zampieri 1 Généalogie partielle des langages de programmation FORTRAN BASIC PL/1 PROLOG ALGOL60 COBOL C PASCAL ADA MODULA-2

Plus en détail

L héritage Encore un petit topo des familles. Je pense qu'avec ce genre de chapitre, ce n'est pas du luxe...

L héritage Encore un petit topo des familles. Je pense qu'avec ce genre de chapitre, ce n'est pas du luxe... L héritage Encore un petit topo des familles. Je pense qu'avec ce genre de chapitre, ce n'est pas du luxe... Une classe hérite d'une autre classe par le biais du mot clé extends. Une classe ne peut hériter

Plus en détail

Précis de vocabulaire Orienté Objet

Précis de vocabulaire Orienté Objet Dernière Mise à jour : Mars 2007 Précis de vocabulaire Orienté Objet 1 Questions Expliquer et donner un exemple pour chacun des concepts suivants 1. Qu'est-ce qu'un objet? 2. Qu'est-ce qu'une classe? 3.

Plus en détail

Tableaux (introduction) et types de base

Tableaux (introduction) et types de base Tableaux (introduction) et types de base A. Motivation..................................................... 4 B. Les tableaux.................................................... 5 C. Construction des tableaux.......................................

Plus en détail

Claude Delannoy. Exercices C++ en langage. 3 e édition. Groupe Eyrolles, 1997, 1999, 2007, ISBN : 978-2-212-12201-5

Claude Delannoy. Exercices C++ en langage. 3 e édition. Groupe Eyrolles, 1997, 1999, 2007, ISBN : 978-2-212-12201-5 Claude Delannoy Exercices en langage C++ 3 e édition Groupe Eyrolles, 1997, 1999, 2007, ISBN : 978-2-212-12201-5 Chapitre 3 Les fonctions Rappels Généralités Une fonction est un bloc d instructions éventuellement

Plus en détail

INTRODUCTION A JAVA. Fichier en langage machine Exécutable

INTRODUCTION A JAVA. Fichier en langage machine Exécutable INTRODUCTION A JAVA JAVA est un langage orienté-objet pur. Il ressemble beaucoup à C++ au niveau de la syntaxe. En revanche, ces deux langages sont très différents dans leur structure (organisation du

Plus en détail

Syntaxe du langage JAVA. Philippe Roose (IUT Bayonne) Olivier Dedieu (INRIA)

Syntaxe du langage JAVA. Philippe Roose (IUT Bayonne) Olivier Dedieu (INRIA) Syntaxe du langage JAVA Philippe Roose (IUT Bayonne) Olivier Dedieu (INRIA) Structure du langage Les types primitifs boolean(true/false), byte (1 octet), char (2 octets), short (2 octets), int (4 octets),

Plus en détail

Java - Historique. Une introduction à Java. Premier exemple. Aperçu de Java. Processus d obtention d un exécutable. Compilation/interprétation

Java - Historique. Une introduction à Java. Premier exemple. Aperçu de Java. Processus d obtention d un exécutable. Compilation/interprétation Java - Historique Une introduction à Java IFT 287 (Semaine 1) UNIVERSITÉ DE SHERBROOKE 1 Développé par Sun Microsystems en 1994 Inventeur James Gosling (canadien!) Objectif langage sûr (fortement typé)

Plus en détail

Initiation à JAVA et à la programmation objet. raphael.bolze@ens-lyon.fr

Initiation à JAVA et à la programmation objet. raphael.bolze@ens-lyon.fr Initiation à JAVA et à la programmation objet raphael.bolze@ens-lyon.fr O b j e c t i f s Découvrir un langage de programmation objet. Découvrir l'environnement java Découvrir les concepts de la programmation

Plus en détail

Surcharge et Redéfinition.

Surcharge et Redéfinition. Surcharge et Redéfinition. Surcharge et Redéfinition...1 La surcharge...1 Type déclaré et type réel....2 Algorithme de résolution de la surcharge....2 La redéfinition...4 Exécution de service...5 Exemple

Plus en détail

Programmation Java. Redéfinition de méthode (masquage)

Programmation Java. Redéfinition de méthode (masquage) Programmation Java Programmation objet avec Java Concepts plus avancés Christelle Urtado & Sylvain Vauttier Janvier 2013 Redéfinition de méthode (masquage) Une sous-classe peut redéfinir le code de méthodes

Plus en détail

Une introduction à Java

Une introduction à Java Une introduction à Java IFT 287 (Semaine 1) UNIVERSITÉ DE SHERBROOKE 1 Java - Historique Développé par Sun Microsystems en 1994 Inventeur James Gosling (canadien!) Objectif langage sûr (fortement typé)

Plus en détail

Traduction des Langages : Le Compilateur Micro Java

Traduction des Langages : Le Compilateur Micro Java BARABZAN Jean-René OUAHAB Karim TUCITO David 2A IMA Traduction des Langages : Le Compilateur Micro Java µ Page 1 Introduction Le but de ce projet est d écrire en JAVA un compilateur Micro-Java générant

Plus en détail

1. Les fondements de l informatique 13

1. Les fondements de l informatique 13 Introduction à l'algorithmique 1. Les fondements de l informatique 13 1.1 Architecture de Von Neumann 13 1.2 La machine de Turing 17 1.3 Représentation interne des instructions et des données 19 1.3.1

Plus en détail

Listes et arbres binaires

Listes et arbres binaires Des structures de données dynamiques Listes, Listes ordonnées Arbres binaires, arbre binaires de recherche Listes chaînées Utile si le nombre d éléments n est pas connu à l avance et évolue beaucoup. Permet

Plus en détail

Cours d Analyse, Algorithmique Elements de programmation

Cours d Analyse, Algorithmique Elements de programmation 1 de 33 Cours d Analyse, Algorithmique Elements de programmation Florent Hivert Mél : Florent.Hivert@lri.fr Adresse universelle : http://www.lri.fr/ hivert 2 de 33 Données et instructions Un programme

Plus en détail

Introduction à la programmation orientée objet

Introduction à la programmation orientée objet 1. De la programmation par Goto à la programmation structurée Introduction à la programmation orientée objet 1.1. Branchement par Goto * Un simple test sur les valeurs des données: * Plus l'application

Plus en détail

Compilation séparée. Compilation séparée. ENSIIE: Programmation avancée, Compilation séparée, Modularité, Spécifications algébriques 1

Compilation séparée. Compilation séparée. ENSIIE: Programmation avancée, Compilation séparée, Modularité, Spécifications algébriques 1 Compilation séparée Compilation séparée ENSIIE: Programmation avancée, Compilation séparée, Modularité, Spécifications algébriques 1 Compilation séparée Modularité GCC : 4 millions de lignes de code Noyau

Plus en détail

Cours 1 : Introduction Générale + Objet

Cours 1 : Introduction Générale + Objet Organisation du cours Équipe pédagogique L2 S4 2009 : 2010 Programmation Objet Jean-Claude MARTIN MARTIN@LIMSI.FR Cours 1 : Introduction Générale + Objet 10 cours de 1h30 o Jean-Claude MARTIN (MARTIN@LIMSI.FR)

Plus en détail

Correction langage Java

Correction langage Java MINISTÈRE DE L ÉCOLOGIE, DU DÉVELOPPEMENT DURABLE, DES TRANSPORTS ET DU LOGEMENT EXAMEN PROFESSIONNEL DE VÉRIFICATION D APTIDUDE AUX FONCTIONS DE PROGRAMMEUR Session 2010 Correction langage Java Langage:

Plus en détail

Introduction à OCAML

Introduction à OCAML Introduction à OCAML Plan L interpréteur intéractif Ocaml Les types de base, et leurs opérations : int, float, char, string, bool Les n-uplets Conditionnelles : if... then... else et match... with... Déclarations

Plus en détail

Langages de haut niveau

Langages de haut niveau Langages de haut niveau Introduction Un assembleur est un programme traduisant en code machine un programme écrit à l'aide des mnémoniques Les langages d'assemblage représentent une deuxième génération

Plus en détail

Formation C++ avancée

Formation C++ avancée Formation C++ avancée ou comment être les stars du C++ Raffi Enficiaud INRIA 16-18 février 2009 INRIA - IMEDIA Formation C++ avancée Organisation générale Enficiaud (INRIA) C++ 16-18/02/2009 2 / 201 À

Plus en détail

POO 1/3 - Introduction à la Programmation Orientée Objet. Pierre Parrend IUT Lumière Lyon II, 2005-2006 pierre.parrend@univ-lyon2.

POO 1/3 - Introduction à la Programmation Orientée Objet. Pierre Parrend IUT Lumière Lyon II, 2005-2006 pierre.parrend@univ-lyon2. POO 1/3 - Introduction à la Programmation Orientée Objet Pierre Parrend IUT Lumière Lyon II, 2005-2006 pierre.parrend@univ-lyon2.fr Sommaire Les Langages de Programmation Premier Programme Les Objets Objets

Plus en détail

Analyse de programme

Analyse de programme Analyse de programme À quoi ça sert? Comment ça marche? Bertrand Jeannet et Alain Girault INRIA Rhône-Alpes 25 janvier 2012 A. Girault et B. Jeannet (INRIA) Analyse de programme 25 janvier 2012 1 / 41

Plus en détail

Institut Supérieure Aux Etudes Technologiques De Nabeul. Département Informatique

Institut Supérieure Aux Etudes Technologiques De Nabeul. Département Informatique Institut Supérieure Aux Etudes Technologiques De Nabeul Département Informatique Support de Programmation Java Préparé par Mlle Imene Sghaier 2006-2007 Chapitre 1 Introduction au langage de programmation

Plus en détail

Cours 3 SDA et conception de logiciel. 1. Exemple d'analyse algorithmique n'utilisant que des tableaux

Cours 3 SDA et conception de logiciel. 1. Exemple d'analyse algorithmique n'utilisant que des tableaux Cours 3 SDA et conception de logiciel Les SDA servent à pouvoir construire des logiciels performants en cherchant à combiner des "briques" dont on sait qu'on pourra les implémenter en utilisant des techniques

Plus en détail

Informatique III: Programmation en C++ Introduction. Examens. Chargé de cours François Fleuret francois.fleuret@epfl.ch

Informatique III: Programmation en C++ Introduction. Examens. Chargé de cours François Fleuret francois.fleuret@epfl.ch Informatique III: Programmation en C++ Lundi 24 Octobre 2005 Chargé de cours François Fleuret francois.fleuret@epfl.ch Assistant Mathieu Salzmann mathieu.salzmann@epfl.ch Assistants étudiants Ali Al-Shabibi

Plus en détail

Rapport Écriture d'un compilateur

Rapport Écriture d'un compilateur Rapport Écriture d'un compilateur Traduction I ; 2011-2012 Julien VAUBOURG Pierrick LAUFFENBURGER 2A / TRS Introduction Durant ce projet, nous avons travaillé sur la conception d'un compilateur, qui transforme

Plus en détail

Concepts des langages de. Introduction à Clojure

Concepts des langages de. Introduction à Clojure Concepts des langages de programmation Introduction à Clojure Plan C'est quoi clojure? Types et structures de données Fonctions et expressions dans Clojure Commentaires en Clojure Définition de variables

Plus en détail

Programmation objet en Java.

Programmation objet en Java. Programmation objet en Java. Didier Rémy 2001-2002 http://cristal.inria.fr/ remy/mot/7/ http://www.enseignement.polytechnique.fr/profs/informatique/didier.remy/mot/7/ Cours Exercices Slide 1 1. Classes,

Plus en détail

Cours No 3 : Identificateurs, Fonctions, Premières Structures de contrôle.

Cours No 3 : Identificateurs, Fonctions, Premières Structures de contrôle. Université Montpellier-II UFR des Sciences - Département Informatique - Licence Informatique UE GLIN302 - Programmation Applicative et Récursive Cours No 3 : Identificateurs, Fonctions, Premières Structures

Plus en détail

Rappels Java. V.Marangozova-Martin. 1 Classes, instanciation, objets, main

Rappels Java. V.Marangozova-Martin. 1 Classes, instanciation, objets, main Rappels Java V.Marangozova-Martin 1 Classes, instanciation, objets, main Java est un langage pour la programmation orientée-objet (POO). La programmation par objets permet de structurer les programmes

Plus en détail

Fondements de l informatique: Examen Durée: 3h

Fondements de l informatique: Examen Durée: 3h École polytechnique X2013 INF412 Fondements de l informatique Fondements de l informatique: Examen Durée: 3h Sujet proposé par Olivier Bournez Version 3 (corrigé) L énoncé comporte 4 parties (sections),

Plus en détail

Algorithmique Programmation

Algorithmique Programmation Algorithmique Programmation 2ème partie DUT en alternance CNAM 2007-2008 2 Table des matières 1 Premiers Pas en Programmation Objet : les Classes et les Objets 7 1.1 Définir une Classe........................................

Plus en détail

Recherche dans un tableau

Recherche dans un tableau Chapitre 3 Recherche dans un tableau 3.1 Introduction 3.1.1 Tranche On appelle tranche de tableau, la donnée d'un tableau t et de deux indices a et b. On note cette tranche t.(a..b). Exemple 3.1 : 3 6

Plus en détail

Projet de Programmation Fonctionnelle

Projet de Programmation Fonctionnelle Projet de Programmation Fonctionnelle L objectif de ce projet est de concevoir, en Objective Caml, un évaluateur pour le langage mini-ml (un sous ensemble du langage Objective Caml). Votre programme devra

Plus en détail

DS Informatique Scientifique

DS Informatique Scientifique DUT Mesures Physiques - semestre S'2 DS Informatique Scientifique 10 décembre 2012 0. Directives Durée : 2h Tout système électronique interdit (calculatrice, téléphone, etc). Téléphone portable éteint

Plus en détail

Grandes lignes ASTRÉE. Logiciels critiques. Outils de certification classiques. Inspection manuelle. Definition. Test

Grandes lignes ASTRÉE. Logiciels critiques. Outils de certification classiques. Inspection manuelle. Definition. Test Grandes lignes Analyseur Statique de logiciels Temps RÉel Embarqués École Polytechnique École Normale Supérieure Mercredi 18 juillet 2005 1 Présentation d 2 Cadre théorique de l interprétation abstraite

Plus en détail

Machine de Turing. Informatique II Algorithmique 1

Machine de Turing. Informatique II Algorithmique 1 Machine de Turing Nous avons vu qu un programme peut être considéré comme la décomposition de la tâche à réaliser en une séquence d instructions élémentaires (manipulant des données élémentaires) compréhensibles

Plus en détail

Algorithmique et Analyse d Algorithmes

Algorithmique et Analyse d Algorithmes Algorithmique et Analyse d Algorithmes L3 Info Cours 5 : Structures de données linéaires Benjamin Wack 2015-2016 1 / 37 La dernière fois Logique de Hoare Dichotomie Aujourd hui Type Abstrait de Données

Plus en détail

Programmer en JAVA. par Tama (tama@via.ecp.fr( tama@via.ecp.fr)

Programmer en JAVA. par Tama (tama@via.ecp.fr( tama@via.ecp.fr) Programmer en JAVA par Tama (tama@via.ecp.fr( tama@via.ecp.fr) Plan 1. Présentation de Java 2. Les bases du langage 3. Concepts avancés 4. Documentation 5. Index des mots-clés 6. Les erreurs fréquentes

Plus en détail

Programmation orientée objet : le cas de C++

Programmation orientée objet : le cas de C++ Ecole Doctorale MathIf Programmation orientée objet : le cas de C++ Violaine Louvet 1 1 ICJ - CNRS Année 2009-2010 Objectifs de ce cours Connaître et comprendre les concepts de la programmation orientée

Plus en détail

Introduction à Java. Matthieu Herrb CNRS-LAAS. Mars 2014. http://homepages.laas.fr/matthieu/cours/java/java.pdf

Introduction à Java. Matthieu Herrb CNRS-LAAS. Mars 2014. http://homepages.laas.fr/matthieu/cours/java/java.pdf Introduction à Java Matthieu Herrb CNRS-LAAS http://homepages.laas.fr/matthieu/cours/java/java.pdf Mars 2014 Plan 1 Concepts 2 Éléments du langage 3 Classes et objets 4 Packages 2/28 Histoire et motivations

Plus en détail

Licence d'informatique 2004-2005 Examen Programmation orientée objet Juin 2005

Licence d'informatique 2004-2005 Examen Programmation orientée objet Juin 2005 Licence d'informatique 2004-2005 Examen Programmation orientée objet Juin 2005 Durée de l'épreuve : 2 heures TRÈS IMPORTANT : respectez l'ordre des questions. La lisibilité sera un critère important pour

Plus en détail

Cours de compilation

Cours de compilation Cours de compilation 1 Introduction Un compilateur est un logiciel de traduction d un langage source vers un langage cible. D ordinaire le langage source est un langage de programmation évolué, comme C++

Plus en détail

LMI 2. Programmation Orientée Objet POO - Cours 9. Said Jabbour. jabbour@cril.univ-artois.fr www.cril.univ-artois.fr/~jabbour

LMI 2. Programmation Orientée Objet POO - Cours 9. Said Jabbour. jabbour@cril.univ-artois.fr www.cril.univ-artois.fr/~jabbour LMI 2 Programmation Orientée Objet POO - Cours 9 Said Jabbour jabbour@cril.univ-artois.fr www.cril.univ-artois.fr/~jabbour CRIL UMR CNRS 8188 Faculté des Sciences - Univ. Artois Février 2011 Les collections

Plus en détail

Structure d un programme et Compilation Notions de classe et d objet Syntaxe

Structure d un programme et Compilation Notions de classe et d objet Syntaxe Cours1 Structure d un programme et Compilation Notions de classe et d objet Syntaxe POO 1 Programmation Orientée Objet Un ensemble d objet qui communiquent Pourquoi POO Conception abstraction sur les types

Plus en détail

Correction de programmes : Logique de Hoare

Correction de programmes : Logique de Hoare 16 juillet 2009 Logique et informatique Vis-à-vis de l informatique la logique a au moins 2 rôles : 1 Externe et théorique (fondements de l informatique - Électif en S4) : Logique comme méta-informatique

Plus en détail

Algorithmique - Techniques fondamentales de programmation Exemples en Python (nombreux exercices corrigés) - BTS, DUT informatique

Algorithmique - Techniques fondamentales de programmation Exemples en Python (nombreux exercices corrigés) - BTS, DUT informatique Introduction à l'algorithmique 1. Les fondements de l informatique 13 1.1 Architecture de Von Neumann 13 1.2 La machine de Turing 17 1.3 Représentation interne des instructions et des données 19 1.3.1

Plus en détail

Exception en Java. Le principe général des exceptions. La syntaxe des exceptions.

Exception en Java. Le principe général des exceptions. La syntaxe des exceptions. Exception en Java. Exception en Java....1 Le principe général des exceptions...1 La syntaxe des exceptions....1 La hiérarchie des exceptions:...2 Exemple d'exception....3 Exception et signature de service....4

Plus en détail

Plan du cours. Syntaxe abstraite. Actions sémantiques Exemple : Analyseur d expressions arithmétiques Arbres de syntaxe.

Plan du cours. Syntaxe abstraite. Actions sémantiques Exemple : Analyseur d expressions arithmétiques Arbres de syntaxe. Plan du cours Syntaxe abstraite Martin Odersky 21 et 22 novembre 2005 version 1.0 1 2 3 Syntaxe abstraite Martin Odersky 1 de 31 Syntaxe abstraite Martin Odersky 2 de 31 Un analyseur syntaxique fait généralement

Plus en détail

Projet 1 ENS Lyon L3IF

Projet 1 ENS Lyon L3IF Projet 1 ENS Lyon L3IF Génération de code Sébastien Briais 8 janvier 2008 Dans cette partie, vous allez devoir implémenter le générateur de code pour l émulateur DLX risc-emu. À rendre pour le 18 janvier

Plus en détail

MODULE TransportsAbstrait; TYPE Véhicule* = POINTER TO ABSTRACT RECORD prix*: REAL; nbpassmax*: INTEGER END;

MODULE TransportsAbstrait; TYPE Véhicule* = POINTER TO ABSTRACT RECORD prix*: REAL; nbpassmax*: INTEGER END; MODULE TransportsAbstrait; Véhicule = POINTER TO ABSTRACT RECORD prix: REAL; nbpassmax: INTEGER ChoseTransportée =POINTER TO ABSTRACT RECORD poids: REAL; ident: ARRAY 81 OF CHAR PROCEDURE (v: Véhicule)

Plus en détail

Design Pattern (1/3) Design Pattern (2/3)

Design Pattern (1/3) Design Pattern (2/3) Design Pattern (1/3) Un pattern (ou design pattern) décrit : une situation constituant un problème souvent rencontré dans le développement d'applications une (ou plusieurs) solution(s) type(s) à ce problème,

Plus en détail

Langage C. Chapitre 2. 2.1 Le langage C, un langage non interprété. 2.1.1 L écriture du programme. 2.1.2 La compilation

Langage C. Chapitre 2. 2.1 Le langage C, un langage non interprété. 2.1.1 L écriture du programme. 2.1.2 La compilation Chapitre 2 Langage C 2.1 Le langage C, un langage non interprété Le C est un langage de programmation comme il en existe beaucoup d autres (C++, Fortran, Python, Matlab, IDL, ADA...). Il existe deux grandes

Plus en détail

Encapsulation. L'encapsulation consiste à rendre les membres d'un objet plus ou moins visibles pour les autres objets.

Encapsulation. L'encapsulation consiste à rendre les membres d'un objet plus ou moins visibles pour les autres objets. Encapsulation L'encapsulation consiste à rendre les membres d'un objet plus ou moins visibles pour les autres objets. La visibilité dépend des membres : certains membres peuvent être visibles et d'autres

Plus en détail

Une introduction au langage C++ Marc Jachym, Lurpa

Une introduction au langage C++ Marc Jachym, Lurpa Une introduction au langage C++ Marc Jachym, Lurpa Janvier 2008 À l origine, le langage C Langage procédural créé dans les années 1970 aux laboratoires Bell (ATT : télécoms américains) en vue d écrire

Plus en détail

Notion de portée locale (1)

Notion de portée locale (1) Notion de portée locale (1) Les notions de portée locale v.s. globale définies pour les blocs sont également valides dans le cadre des fonctions 1. Comme dans le cas des blocs, la portée permet de résoudre

Plus en détail

nulles dans un langage à objets

nulles dans un langage à objets Prévention de déréférencement de références nulles dans un langage à objets Jean-Sébastien Gélinas, Étienne M. Gagnon, Jean Privat Université du Québec à Montréal Langages et Modèles à Objets Nancy 27

Plus en détail

INITIATION A LA PROGRAMMATION ORIENTEE OBJET (POO)

INITIATION A LA PROGRAMMATION ORIENTEE OBJET (POO) Objectifs INITIATION A LA PROGRAMMATION ORIENTEE OBJET (POO) Bertrand Vandeportaele IUT GEII TOULOUSE 2015 Objectifs Connaître les possibilités offertes par la POO Comprendre les concepts Savoir utiliser

Plus en détail

S. Laporte C# mode console DAIGL TS1

S. Laporte C# mode console DAIGL TS1 Bases du langage C# I. C# en mode console (mode texte) Avantages par rapport au mode graphique (Application Windows): - C'est un mode plus proche de l'approche algorithmique (pas de notions de composants,

Plus en détail