« Programmation C++/Les structures/Exercices » : différence entre les versions
Contenu supprimé Contenu ajouté
→EXERCICE 3 : ortho |
ortho + mise en forme |
||
Ligne 4 :
=== Présentation ===
Nous avons utilisé pour l'instant des types de base : ils contiennent des éléments de type int, char, double ou bool. Dans ce chapitre nous allons définir de nouveaux types qui vont permettre de représenter des entités plus complexes. Par exemple, on pourra définir un type point qui contiendra une abscisse et une ordonnée. Nous allons donc apprendre à créer et à utiliser des types structurés.<br/>
Nous verrons ensuite comment, à partir de ces types, nous pouvons créer des fonctions permettant de manipuler ces nouveaux types. L'association de ces types et de ces fonctions sera appelée module, chacun sera défini par un fichier
Nous étudierons finalement un type de structure très usuel : les listes. Dans ce chapitre, notre représentation des listes sera très sommaire mais sera l'occasion de découvrir une méthodologie de programmation en découpant notre programme en différents modules qui seront dans une certaine mesure indépendants. Cette méthodologie nous permettra de concevoir des programmes de taille plus importante.
Ligne 63 :
</source>
**'''Explications'''
**Dans cet exemple, nous
**Dans la fonction main, on définit 3 points a,b et c.
**On fixe les coordonnées du point a à (3.2,6.4).
Ligne 163 :
=== Décomposition d'un programme en plusieurs fichiers ===
Nos programmes vont désormais être découpés en plusieurs fichiers : certains seront des fichiers
Chaque programme sera constitué de modules : chaque module sera défini par un fichier <tt>.h</tt> et un fichier <tt>.cpp</tt>. Chaque module aura une fonctionnalité bien définie. Il comportera en général la définition d'une structure et des fonctions permettant de manipuler ces structures. <br/>
Cette approche nous permet d'améliorer petit à petit notre méthodologie de programmation. <br/>
Ligne 179 :
- #include "point.h" <br/>
- les fonctions manipulant des points. <br/>
*On a ainsi créé un module réutilisable permettant de manipuler des points. Lorsque le programme principal voudra utiliser notre module point, il faudra rajouter <tt>#include"point.h"</tt>.
*Sur des petits programmes cette structuration semble être une perte de temps. En fait cela permet de gagner du temps de débogage et cette méthodologie devient indispensable dès que l'application devient conséquente.
=== Le programme principal ===
Notre programme est désormais constitué de 3 fichiers : <br/>
*Les fichiers <tt>point.h</tt> et <tt>point.cpp</tt> qui définissent un module point.
*Le fichier main.cpp qui contient la fonction main. Ce fichier utilise le module point et commence donc par <tt>#include "point.h"</tt>.
=== Les fichiers
Un programme peut être constitué d'un grand nombre de modules : par exemple imaginons qu'un programme soit constitué de 4 modules A, B, C et D. <br/>
On suppose que B et C utilisent les notions définies dans A : ils commencent donc tous les deux par <tt>#include"A.h"</tt>. <br/>
On suppose que le module D utilise les notions définies dans B et dans C. D commence donc par <tt>#include"B.h"</tt> et <tt>#include"C.h"</tt>. <br/>
Le module A sera donc défini 2 fois dans le module D une fois lors de l'inclusion de <tt>B.h</tt> et une deuxième fois lors de l'inclusion de <tt>C.h</tt>. Le compilateur refusera de compiler notre programme !
=== Fichier
Le fichier .h d'un module A commencera par <tt>#ifndef A_H</tt> et se terminera par <tt>#endif</tt>. <br/>
La directive de compilation <tt>#ifndef</tt> permet d'inclure le code situé entre le <tt>#ifndef</tt> et <tt>#endif</tt> uniquement si la macro <tt>A_H</tt> n'est pas déjà définie.
Juste après <tt>#ifndef A_H</tt>, on va justement définir la macro <tt>A_H</tt> en écrivant <tt>#define A_H</tt>. <br/>
La deuxième fois qu'on voudra inclure <tt>A.h</tt>, la macro <tt>A_H</tt> étant définie, le code du fichier <tt>A.h</tt> ne sera pas inclus. <br/>
Grâce à cette méthode, les définitions contenues dans les fichiers <tt>.h</tt> ne seront inclues qu'une seule fois.
=== Exemple 3 : programmation modulaire ===
Ligne 274 ⟶ 275 :
*'''Explications'''
**Le fichier point.h va contenir :
***l'utilisation des directives <tt>#ifndef</tt>, <tt>#define</tt> et <tt>#endif</tt> pour éviter l'inclusion multiple des fichiers <tt>.h</tt>.
***la définition de la structure point
***les entêtes des fonctions manipulant des points.
**Le fichier <tt>point.cpp</tt> commence par <tt>#include "point.h"</tt>. Comme il utilise <tt>cin</tt> et <tt>cout</tt>, il contient aussi <tt>#include
**Le fichier <tt>main.cpp</tt> contient notre fonction <tt>main()</tt> qui est identique à celle de l'exemple 2.
=== Structuration de notre programme et de notre réflexion ===
*Au lieu d'avoir un seul grand fichier contenant le main et toutes les fonctions , il y a plusieurs petits fichiers .
*Lorsqu'on écrit le fichier <tt>point.h</tt>, on réfléchit à la spécification de chaque fonction : QUE fait notre fonction ?
*Lorsqu'on écrit le fichier <tt>point.cpp</tt>, on réfléchit à comment on implémente ces spécifications : COMMENT
*Lorsqu'on écrit notre
=== Gérer une liste d'employés ===
| |||