Cours programmation 4.doc - Edouard Lopez

Licence SHS, UFR S&M
Université Bordeaux 2
Support du cours Programmation 4
Programmation 4
Jean Marc Salotti Sommaire 1. Rappels sur la plateforme Delphi 5
1.1 Eléments de l'interface 5
1.2 Différents types de fichiers 6
1.3 Interface et implémentation 7
1.4 Utilisation des composants visuels 7
1.5 Exemple de programme écrit avec Delphi 8
2. Rappels sur les procédures et fonctions 9
2.1 Rôles des procédures et fonctions 9
2.2 Syntaxe de déclaration 9
2.3 Visibilité des variables locales 9
2.4 Appels des procédures et des fonctions 10
2.5 Passage par valeur ou par référence 10
2.6 Exercices 11
3. Outils de l'interface 13
3.1 Fiches 13
3.2 Panneaux et fenêtres 13
3.3 Récupération de données 13
3.4 Outils pour la sélection 13
3.5 Outils pour la visualisation 13
3.6 Outils de dialogue 13
3.7 Autres 13
4. Dessins sur objets TCanvas 14
4.1 Propriété canvas 14
4.2 Principales propriétés des objets TCanvas 14
4.3 Principales méthodes des objets TCanvas 14
4.4 Accès à la couleur des pixels 15
4.5 Gestion de l'affichage 16
4.6 Exercices 16
5. Gestion des erreurs et des interruptions 17
5.1 Débogage 17
5.2 Gestion des interruptions 17
5.3 Try Except 18
5.4 Try Finally 18
5.5 Création de nouvelles classes d'erreur 18
5.6 Exercices 19
6. Démarche analyse programmation par structuration hiérarchique
descendante 20
6.1 Description générale de la méthode 20
6.2 Analyse fonctionnelle 20
6.3 Analyse organique 20
6.4 Ecriture du programme 20
6.5 Mise au point du programme 21
6.6 Tests 21
6.7 Réalisation d'un dossier d'analyse programmation 21
6.8 Exercice 21
7. Analyse programmation du jeu Othello 23
7.1 Analyse fonctionnelle 23
7.2 Analyse organique 23
8. Othello, décomposition modulaire 25
8.1 Module affichage 25
8.2 Module dédié à la gestion du jeu 25
8.3 Module dédié au jeu de l'ordinateur 26
9. Ecriture détaillée du programme Othello 28
9.1 Procédure principale du jeu de l'ordinateur 28
9.2 Exercice 1 : Raisonnement par cas 28
9.3 Exercice 2 : Sommation 28
9.4 Exercice 3 : Efficacité dans la simplicité 29
9.5 Exercice 4 : Création de liste 29
9.6 Exercice 5 : Mise en place d'une stratégie 29
9.7 Phase de tests 29
10. Introduction à la complexité algorithmique 31
10.1 Estimation de la durée des calculs 31
10.2 Complexité algorithmique 31
10.3 Exemple 1 31
10.4 Exemple 2 32
10.5 Exemple 3 32
11. Compléments, bases de données, DLL 34
11.1 Bases de données 34
11.2 Expert base de données 34
11.3 Interrogation d'une base de données 34
11.4 DLL 34
11.5 Construction d'une DLL 35
12. Conclusion, synthèse 36
12.1 Ce qu'il faut retenir 36
12.2 Cours et travaux pratiques 36
12.3 Ouvertures 36
12.4 Place de l'informatique 36
TPs :
1. Création de classes, manipulation des objets 2. Héritage
Manipulation de classes 3. Polymorphisme 4. Complexité algorithmique 5. Gestion des erreurs 6. Gestion de la souris 7. Projet 1 8. Projet 2 9. Projet 3 10. Projet 4 11. Projet 5 12. Projet 6
Annexes : Liste des TD-TP Rappels sur la plateforme Delphi
1 Eléments de l'interface . Menus déroulants avec entre autres :
menus pour l'édition
options de compilation
options de l'environnement
. Palette de composants
. Inspecteur d'objets
. Fiche
. Editeur de langage Pascal [pic] Pour créer une application simple, il faut placer des composants, boutons,
fenêtre d'édition etc. sur la fiche à l'aide de la souris (clic sur le
composant de la palette, puis clic sur la fiche). Ensuite, il faut associer
des événements aux composants, souvent par simple double clic sur celui-ci
(c'est le cas des boutons). Delphi insère alors de façon automatique
quelques lignes de code dans la fenêtre d'édition, notamment l'entête de la
procédure Pascal qui va être appelée lorsque l'événement est déclenché (par
exemple le clic du bouton). Il ne reste plus qu'à compléter la procédure.
Voir l'exemple qui suit après double clic sur le bouton "Button1".
[pic]
2 Différents types de fichiers On trouve 3 types essentiels de fichier :
. *.dpr = Delphi Project
Les instructions de ce fichier, exécutées en premier, servent à référencer
les unités utilisées, à créer les premières fiches et à placer le programme
en attente d'événements. C'est là que se trouve le "bloc principal", qu'on
retrouve également en mode "console".
program nom_du_programme;
uses forms, // Pour exploiter les fiches
unité1 in 'nomfic1.pas', unité2 in 'nomfic2.pas', ...;
{$R *.res} // Intégration des ressources éventuelles définies dans le
.res
begin
Application.Initialize;
Application.CreateForm(TForm1, Form1); // Création de la fiche
Application.run; // Boucle infinie, attente d'événements souris,
clavier, etc.
end. . *.pas = unité Pascal
Toutes les procédures et fonctions développées en Pascal sont enregistrées
dans ces fichiers. Ces unités sont généralement associées à des fiches de
même nom mais de type *.dfm. On peut toutefois ajouter de nouvelles unités
Pascal sans y associer de fiches. . *.dfm = Delphi Form
Ces fichiers, non éditables, sont automatiquement générés et gérés par
Delphi. Ils enregistrent les informations concernant les fiches (TForm)
utilisées dans l'application. Il existe aussi des *.dcu (Delphi Compiled Unit) qui sont générés par
Delphi lors de la compilation, ainsi que des *.res (ressources) et d'autres
fichiers pour sauvegarder l'état des fichiers de la plateforme et les
options de l'éditeur. Le .dpr, les .pas et les .dfm suffisent généralement
pour sauvegarder une application. Bien entendu, un exécutable de type .exe
est également généré lors de l'édition des liens (fusion des .dcu). Les
fichiers de type *.~pas sont des sauvegardes de la version précédente de
l'unité *.pas de même nom. 3 Interface et implémentation Une unité Pascal est constituée de 2 grandes parties, la partie Interface
et la partie Implémentation.
Sont déclarés dans la partie interface tous les types ainsi que toutes les
procédures et fonctions mis à disposition des autres unités. Il s'agit de
connaître l'entête, c'est-à-dire la liste des paramètres et leur type pour
chaque procédure et fonction (afin de savoir comment elles peuvent être
appelées, ce qui justifie le terme interface), ainsi que la liste des
variables globales.
Le contenu exact de chaque procédure et fonction, ainsi que la liste des
procédures et fonctions internes à l'unité sont décrits dans la partie
implémentation. unit nom_unité;
interface
uses unité_nécessaire1, unité_nécessaire2, ...; // Nécessaire pour
l'interface
const // Définition des nouvelles constantes accessibles
dans cette unité
type // Définition des nouveaux types accessibles dans cette
unité
// Les objets comme TForm sont des types
var // Définition des variables globales accessibles dans
cette unité
procedure nomproc1(...); // Déclaration des entêtes des procédures
accessibles
function nom_fct1(...) : nom_type1;; // Entêtes des fonctions
accessibles implementation
uses unité_nécessaire1, unité_nécessaire2, ...; // Nécessaire pour
l'implémentation
// et pas déclarées dans l'interface
const ...
type
var nomvar1 : type1; ... // Variables globales de l'unité, mais
non accessibles
// depuis une autre unité
procedure nomproc1(...);
var ...
begin ... // Instructions de la procédure
end; function nom_fct1(...): nom_type1;
var ...
begin ... Instructions de la fonction
end;
...
end. 4 Utilisation des composants visuels TLabel, TEdit, TMemo, ..., (rappels visuels)
Lors de la sélection d'un composant visuel (qui est un objet) sur la fiche,
l'inspecteur d'objet liste automatiquement ses propriétés (1er onglet) et
ses événements (2ème onglet), qui peuvent être modifiés (position sur la
fiche, largeur, hauteur, couleur de police, transparence, ...). Il est
également possible d'accéder à la valeur de ces propriétés ou de les
modifier à l'exécution avec le signe . suivi du nom de la propriété.
5 Exemple de programme écrit avec Delphi unit Unit1;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics,
Controls, Forms,
Dialogs, StdCtrls;
type
TForm1 = class(TForm)
Button1: TButton;
procedure Button1Click(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
var
Form1: TForm1;
implementation
{$R *.dfm}
procedure TForm1.Button1Click(Sender: TObject); // Appelé lors du clic
sur button1
begin
// Le bouton est déplacé d'1 pixel à droite sauf s'il est déjà au-delà de
300, auquel cas il est
// repositionné contre la marge gauche.
if button1.Left > 300 then button1.Left := 0
else button1.Left := button1.Left + 1;
button1.Caption := 'Hello'; // nouveau texte du bouton
button1.Font.Name := 'Times New Roman'; // Changement de police
end;
end. Vue de l'application au début de l'exécution
[pic] puis après quelques clics sur le bouton :
[pic] Rappels sur les procédures et fonctions
1 Rôles des procédures et fonctions