Remerciez-le!

Remerciez @Admin pour avoir partagé cet document gratuitement, de la manière la plus simple, en partageant sur les réseaux sociaux.

Licence SHS Université Bordeaux 2 Support du cours ASD Algorithmique et Structu

Licence SHS Université Bordeaux 2 Support du cours ASD Algorithmique et Structures de Données avec Delphi Jean Marc Salotti Résumé Intitulé ASD : Algorithmes et structures de données, plateforme Delphi Langue : Français Crédits : 3 Code : Responsable : Jean Marc Salotti Cours : 12 h Heures/semaine : 1 Total semaines : 12 Semestre : 5 T D : 18 h Heures/semaine : 1,5 Total semaines : 12 Semestre : 5 Pré requis Introduction à la programmation, algorithmique de base Contenu Révisions sur Pascal et Delphi. Introduction au langage objet Delphi, à la programmation événementielle, aux composants graphiques de Delphi, utilisation des structures de données listes, piles, manipulation de fichiers textes .ini Objectifs Conception structurée de programmes avec Delphi Méthode Cours ; exercices sur machine en TD Évaluation examen écrit Sommaire 1. Rappels sur le langage Pascal.............................................................................................6 1.1 Syntaxe générale.........................................................................................................6 1.2 Types prédéfinis..........................................................................................................6 1.3 Création de type..........................................................................................................6 1.4 Instructions de base.....................................................................................................6 1.5 Exercices de révision sur les boucles..........................................................................7 2. Révision sur les booléens et les tableaux............................................................................9 2.1 Les booléens................................................................................................................9 2.2 Exercices sur les booléens........................................................................................10 2.3 Exercices sur les tableaux.........................................................................................10 3. Fichiers textes génériques TInifile....................................................................................12 3.1 Introduction...............................................................................................................12 3.2 Organisation d'un fichier .ini.....................................................................................12 3.3 Utilisation d'un objet TInifile....................................................................................12 3.4 Propriétés et méthodes des objets TInifile................................................................12 3.4.1 Lecture dans un fichier .ini...............................................................................13 3.4.2 Ecriture dans un fichier .ini...............................................................................13 3.5 Exemple....................................................................................................................13 4. Introduction au langage objet............................................................................................15 4.1 Utilité des objets.......................................................................................................15 4.2 Exemple....................................................................................................................15 4.3 Classe TForm............................................................................................................16 4.4 Public / Private..........................................................................................................16 4.5 Constructeur..............................................................................................................17 4.6 Destructeur................................................................................................................17 4.7 Affectation................................................................................................................17 4.8 Héritage simple.........................................................................................................17 4.9 Exercice.....................................................................................................................18 5. Héritage et polymorphisme...............................................................................................20 5.1 Surcharge..................................................................................................................20 5.2 Méthode statique.......................................................................................................20 5.3 Méthodes virtuelles...................................................................................................21 5.4 Méthode abstraite......................................................................................................21 5.5 Self............................................................................................................................22 5.6 Opérateurs de classe..................................................................................................22 6. Polymorphisme, étude d'un exemple................................................................................23 6.1 Problème...................................................................................................................23 6.2 Solution.....................................................................................................................23 6.3 Extension...................................................................................................................25 7. Listes chaînées..................................................................................................................26 7.1 Représentation...........................................................................................................26 7.2 Gestion d’une liste chaînée.......................................................................................26 7.3 Liste chaînée dans un tableau...................................................................................26 7.4 Tableaux dynamiques................................................................................................27 7.5 TList..........................................................................................................................27 7.6 Exemple....................................................................................................................28 7.7 Exercices...................................................................................................................29 8. Piles...................................................................................................................................30 8.1 Représentation...........................................................................................................30 8.2 Gestion d’une pile.....................................................................................................30 8.3 Exemples de piles.....................................................................................................30 8.4 Objets TStack............................................................................................................30 8.5 Méthodes de TStack..................................................................................................31 8.6 Exercice.....................................................................................................................31 9. Files...................................................................................................................................33 9.1 Représentation...........................................................................................................33 9.2 Gestion d’une file......................................................................................................33 9.3 Exemple de file.........................................................................................................33 9.4 Objets TQueue..........................................................................................................34 9.5 Méthodes de TQueue................................................................................................34 9.6 Exercice.....................................................................................................................34 10. Listes ordonnées............................................................................................................36 10.1 Concepts....................................................................................................................36 10.2 Tri par insertion.........................................................................................................36 10.3 Tri avec TList............................................................................................................37 10.4 Exemple....................................................................................................................37 10.5 Exercice.....................................................................................................................37 11. Images...........................................................................................................................39 11.1 Structures de données...............................................................................................39 11.2 Algorithmes sur les images.......................................................................................39 12. Révision, synthèse.........................................................................................................40 12.1 Exercices de synthèse...............................................................................................40 12.2 Bilan..........................................................................................................................40 ANNEXES : LISTE DES TD-TP.............................................................................................42 INTRODUCTION Pourquoi Delphi : - parce que le temps est révolu de "programmer dans un langage", on développe des applications informatiques avec une "plateforme de développement". - parce que Delphi permet la programmation événementielle - parce que le langage Pascal Objet est simple et pédagogiquement acceptable - parce que la programmation sous Delphi est très rapide - parce que Delphi permet la conception d'interfaces professionnelles - parce que Delphi est gratuit - parce qu'il existe un grand nombre de programmeurs Delphi dans le monde et que de nombreux composants sont proposés sur le web pour faire par exemple de la reconnaissance vocale, pour récupérer l'image d'un scanner ou d'une caméra, etc. Exemples d'applications présentées en cours et nécessitant très peu de code : - reconnaissance vocale - synthèse vocale, agents animés (Microsoft Agent) - live vidéo et capture d'image en utilisant une webcam Autres applications présentées en cours : - traitement d'images - synthèse d'images - mouvements elliptiques de planètes et astéroïdes autour du soleil - gestion d'arbre généalogique - jeu de simulation de type Age of Empires : Marsbase Connaissances requises pour suivre le cours ASD : Bases du langage Pascal (un polycopié en ligne est disponible pour ceux qui ont besoin d'une mise à niveau, avec cours et exercices corrigés). Justification de la maîtrise d'une plateforme de développement : Les logiciels du commerce ne font pas tout ce qu'on voudrait faire. Il est donc nécessaire d'apprendre à créer soi-même les applications informatiques qui relèvent du domaine des mathématiques appliquées aux sciences humaines et sociales (SHS). Dans le domaine de la recherche, on peut également noter l'application des principaux concepts et méthodes utilisés dans les modèles de systèmes complexes adaptatifs proposés en sciences humaines et sociales (travaux des sociologues, politologues, historiens, ou des économistes Axelrod, Bowles et Gintis, Epstein et Axtell, Schelling). Ils portent sur l'émergence de la communication et du langage, de la coopération, la sélection des normes et l'émergence des institutions, l'étude de systèmes économiques, en particulier des marchés et réseaux de production et d'échange, ou encore sur l'organisation sociale de l'espace. Parmi les concepts et méthodes développés dans ce domaine de recherche figurent les notions d'émergence, d'attracteurs, de lois d'échelle, de régime dynamique, et de transition, de percolation, d'apprentissage, de jeux évolutionnaires etc., dont la modélisation nécessite souvent le développement d'applications informatiques dédiées. 1. Rappels sur le langage Pascal 1.1 Syntaxe générale Pas de différenciation minuscule / majuscule, Les commentaires commencent par /* et finissent par */ ou commencent par (* et par *) Sur une ligne, ce qui est après // est considéré comme commentaires. L'espace et le retour à la ligne sont des séparateurs. Il faut au moins 1 séparateur entre chaque mot-clé ou variable. 1.2 Types prédéfinis Il existe 5 grands types de base : integer, real, boolean = {true, false}, char, string En cas de nécessité, les entiers et les réels peuvent toutefois se décliner en : byte, longint, currency et double La déclaration d'un tableau statique se fait de la façon suivante : array[indice1..indice2] of nom_de_type 1.3 Création de type La création d'un nouveau type est précédée du mot-clé "type". Exemples : type ttab = array[1..100] of real; entier = integer; La déclaration d'une structure composée nécessite le mot clé record et se termine par end; Exemple : rpoint = record x,y : real; end; 1.4 Instructions de base Remarques préliminaires : Dans les descriptions ci-dessous, une expression est une formule mathématique quelconque (par exemple 3*x+1 ou sin(4)) qui aura une valeur à l'exécution du programme, alors qu'une instruction est une opération qui exploite des expressions et éventuellement d'autres instructions mais qui n'a aucune valeur à l'exécution. Instruction d'affectation : nom_de_variable := expression // La variable prend la valeur de l’expression Instruction conditionnelle : if expression booléenne then instruction1 else instruction2 // Jamais de ; avant else Le else est optionnel. Si plusieurs if then else sont imbriqués et qu'il y a ambiguïté, le else se rapporte toujours au then le plus proche qui le précède. Instruction "tant que" : while expression booléenne do instruction Tant que l'expression booléenne est évaluée à true l'instruction après do est répétée. Instruction composée : begin instruction1; instruction2; instruction3; … end; Instruction "répéter jusqu'à" : repeat instruction until expression booléenne Instruction d'itération "pour" : for nom_variable := expression1 to expression2 do instruction // variable non réelle est équivalent à : nom_de_variable := expression1; while nom_de_variable <= expression2 do begin instruction; inc(nom_de_variable); // Augmentation de 1 si c'est un entier end; Variante descendante : for nom_variable := expression1 downto expression2 do instruction Instruction du traitement cas par cas : case expression of : valeur1 : instruction1; valeur2 : instruction2; … else instructionN; end; Notez que l'affectation, l'instruction conditionnelle, le while et l'instruction composée suffisent à écrire n'importe quel programme. D'autres instructions moins fondamentales existent, se rapporter au manuel utilisateur ou à l'aide en ligne. 1.5 Exercices de révision sur les boucles Dans les exercices suivants, on utilisera les fonctions StrToInt pour convertir une chaine de caractères en entier, IntToStr pour la conversion inverse, FloatToStr pour convertir un réel en string et StrToFloat pour la conversion inverse. On utilisera également la méthode TMemo.lines.add( texte ) pour afficher une chaîne de caractères dans un TMemo. 1. Définir les variables et écrire la suite d'instructions permettant de calculer la somme de 10 nombres pairs consécutifs, en commençant à partir de 4. Le résultat est placé dans une variable appelée "res". Solution 1 : var i, pair, res : integer; begin res := 0; pair := 4; for i:=1 to 10 do // 10 passages dans la boucle, car il y a 10 calculs à faire begin res := res + pair; pair := pair + 2; end; end; Solution 2 : var i, res : integer; begin res := 0; for i:=1 to 10 do // toujours 10 passages dans la boucle !!! res := res + i*2 + 2; // Formule en fonction de i end; 2. Ecrire un programme qui demande une valeur de n à l'utilisateur dans un TEdit et qui affiche les n premiers nombres impairs par ordre décroissant dans un TMemo. 3. Soit la suite définie par {U1 = 10; Un+1= 2.Un - 3}. Ecrire un programme qui demande une valeur de n à l'utilisateur dans un TEdit et qui affiche les n premiers membres de cette suite dans un TMemo. 4. Ecrire un programme qui demande à l'utilisateur une valeur de n dans un TEdit et qui affiche le résultat de n! dans un TLabel. 5. Ecrire un programme qui demande à l'utilisateur une valeur pour un réel x et un entier y positif dans 2 TEdit et qui affiche le résultat de xy dans uploads/Management/ cours-delphi-asd2.pdf