Vous êtes sur la page 1sur 27

CPR Informatique

11 octobre 2000
(poste 3159 ou 3164)

Visual C++

Prise en main
Tables des matières

1. – LES MFC (MICROSOFT FOUNDATION CLASSES) .........................................................................................3

1.1 – DÉFINITION .............................................................................................................................................................. 3


1.2 – L’ESPACE DE TRAVAIL ............................................................................................................................................. 3

2. – CRÉER UN NOUVEAU PROJET ............................................................................................................................5

2.1 – ETAPE 1 : CHOISIR LE TYPE ET LE NOM DU PROJET ................................................................................................. 5


2.2 – ETAPE 2 : CHOISIR LE TYPE DE L’APPLICATION ...................................................................................................... 6
2.3 – ETAPE 3 : COMPILATION ET ÉDITION DE LIENS ....................................................................................................... 8
2.4 – ETAPE 4 : EXÉCUTION DU PROGRAMME .................................................................................................................. 9

3. – ENRICHIR UN PROJET .........................................................................................................................................10

3.1 – AJOUTER UNE STRUCTURE .................................................................................................................................... 10


3.2 – AJOUTER UNE CLASSE ........................................................................................................................................... 10
3.3 – AJOUTER UNE MÉTHODE À UNE CLASSE ................................................................................................................ 13
3.4 – AJOUTER UN CHAMP À UNE CLASSE ...................................................................................................................... 15
3.5 – AJOUTER/SUPPRIMER UN FICHIER DANS L’ARBORESCENCE ................................................................................. 16

4. – FERMER UN PROJET.............................................................................................................................................17

5. – OUVRIR UN PROJET EXISTANT........................................................................................................................18

5. – LES « ++ » DE L’ÉDITEUR VISUAL....................................................................................................................19

6. – LES PRINCIPALES FONCTIONNALITÉS DU DÉBOGUEUR VISUAL C++ .............................................22

6.1 – LE MENU « DEBUG » ............................................................................................................................................. 22


6.2 - INSERTION DE POINTS D’ARRÊT ............................................................................................................................. 23
6.3 - L’EXÉCUTION DU PROGRAMME EN MODE “PAS À PAS” ......................................................................................... 24
6.4 - VÉRIFICATION DE LA VALEUR DES VARIABLES ..................................................................................................... 26
1. – Les MFC (Microsoft Foundation Classes)

1.1 – Définition
Les MFC constituent un ensemble de classes prédéfinies autour desquelles s’articule la
programmation Windows avec Visual C++. L’écriture d’un programme Windows entraîne la
création et l’utilisation d’objets des MFC ou d’objets de classes dérivées des MFC. Visual C++
met à la disposition du programmeur des outils spécialisés facilitant considérablement
l’utilisation des MFC. Le générateur de code créé des objets qui contiennent des fonctions
membres permettant la communication avec Windows, le traitement des messages Windows et
l’échange des messages entre eux. Il reste au programmeur à ajouter les fonctions membres et les
champs qui permettent de personnaliser les classes pour doter les programmes de fonctionnalités
spécifiques.
Lorsque l’on crée un projet, Visual C++ définit un espace de travail associé et y enregistre les
informations nécessaires à la gestion du projet (fichiers sources, fichiers de liens …)

1.2 – L’espace de travail


Un environnement intégré contient un éditeur de texte, un compilateur, un éditeur de liens, un
éditeur de ressources, un débogueur et quelques outils (création de bitmap et d’icônes).
A l’ouverture de Visual C++, l’espace de travail est constitué de trois fenêtres principales (Cf.
figure 1) :
• La fenêtre de la gestion du projet permet le déplacement au sein des classes et dans les
fichiers du programme ;
• La fenêtre de l’éditeur permet d’entrer et de modifier le code source des classes et des autres
composants de l’application ;
• La fenêtre des résultats affiche les messages générés par la compilation et l’édition de liens.

IGN / ENSG / CPRI Visual C++ - Prise en main page 3/27


La fenêtre de la
gestion du projet

La fenêtre de l’éditeur

La fenêtre des résultats

figure 1 – Les trois fenêtres principales

IGN / ENSG / CPRI Visual C++ - Prise en main page 4/27


2. – Créer un nouveau projet

2.1 – Etape 1 : choisir le type et le nom du projet


Pour créer un nouveau projet, aller dans le menu File et cliquer sur New.La fenêtre suivante
apparaît :

Nom du projet

Choix du répertoire
de travail

figure 2 – Création d’un nouveau projet : étape 1

Il est possible de créer des projets de types différents en fonction des options choisies. Dans la
plupart des cas, un minimum de code source est généré par Visual C++.
Les deux options principales sont :
• Win32 Console Application. C’est le type de projet le plus simple. Les résultats du
programme sont affichés dans une fenêtre MS-DOS. L’avantage de ce type de projet réside
dans le fait que le code généré ne contient aucun appel aux routines graphiques de Windows
ce qui le rend directement portable sur d’autres environnements (UNIX, MAC …). Le code
généré est simple et succinct ;
• MFC AppWizard (.exe). Cette option est intéressante pour construire des applications
graphiques complexes (interfaces homme-machine). Elle permet d’utiliser des bibliothèques
graphiques de haut niveau, les MFC (Microsoft Foundation Classes), ce qui simplifie
considérablement la tâche du programmeur pour toutes les parties graphiques et la gestion
des événements (souris, clavier …). La lecture du code généré par cette option demande une
connaissance approfondie de la programmation Windows et des MFC. Nous n’en parlerons
pas dans ce document.
Après avoir choisi le type du projet (Win32 Console Application), entrer le nom du projet et
choisir le répertoire de travail (Cf. figure 2).

IGN / ENSG / CPRI Visual C++ - Prise en main page 5/27


2.2 – Etape 2 : choisir le type de l’application
L’étape suivante permet de choisir le type d’application désirée. Nous avons le choix entre trois
options :
• “An empty project” : c’est la seule option qui ne génère rien (aucun code source, aucun
fichier) ;
• “A simple application” génére uniquement le code (vide) de la fonction principale du
programme (“main”) dans un fichier “nom-du-projet.cpp” ;
• “A “Hello Word” application” ajoute une ligne de code dans la fonction main pour
l’affichage de la chaîne de caractère “Hello Word” à l’écran (option choisie pour notre
exemple).

Cliquer sur le bouton Finish pour générer le projet.

figure 3 – Création d’un nouveau projet : étape 2

Le nouvel espace de travail s’ouvre automatiquement. Deux onglets supplémentaires viennent


enrichir la fenêtre de l’espace de travail : ClassView et FileView. Classview affiche
la hiérarchie des classes définies pour le projet (dans notre exemple il n’y a aucune classe
associée au projet – Cf. figure 4) et permet ainsi un déplacement très aisé dans le code de
l’application. FileView répertorie les fichiers source constituant le projet. En “double-
cliquant” sur un nom de fichier, le contenu apparaît dans la fenêtre de l’éditeur (Cf. figure 5).
On note l’inclusion par Visual C++ du fichier stdafx.h. Ce fichier est obligatoire pour la
construction du projet (Cf. figure 5). Tous les #include <fichier.h> doivent
impérativement être déclarés après ce fichier système.

IGN / ENSG / CPRI Visual C++ - Prise en main page 6/27


Aucune classe n’est associée au
projet, seule la fonction main
apparaît dans la hiérarchie

L’onglet ClassView
est sélectionné

figure 4 – L’onglet ClassView

Fichier systématiquement inclus

Le code généré par l’environnement


Visual C++ se trouve dans le fichier
MonProjet.cpp

L’onglet FileView
est sélectionné

figure 5 – L’onglet FileView

IGN / ENSG / CPRI Visual C++ - Prise en main page 7/27


2.3 – Etape 3 : compilation et édition de liens
On construit le projet en cliquant sur l’icône « build » de la barre de menu (Cf. figure 6). Dans
notre exemple, nous avons modifié le code source généré avant la construction du projet
(remplacement de la fonction C printf par la fonction C++ cout et inclusion du fichier
iostream.h contenant cette fonction).

Une fois la compilation et l’édition de liens terminées avec succès (messages dans la fenêtre des
résultats), on peut exécuter le programme en cliquant sur l’icône « Execute Program »
(Cf. figure 7).

Le résultat de l’exécution (affichage de la chaîne de caractères “Hello World “ à l’écran) apparaît


dans une fenêtre MS-DOS (Cf. figure 8).

Construction du
projet (build)

Compte-rendu de la compilation et de
l’édition de liens. Le programme
MonProjet.exe est créé et peut
être exécuté

figure 6 – Construction du projet

IGN / ENSG / CPRI Visual C++ - Prise en main page 8/27


2.4 – Etape 4 : exécution du programme

Exécution du
programme

figure 7 – Exécution du programme

figure 8 – Résultat de l’exécution du programme

IGN / ENSG / CPRI Visual C++ - Prise en main page 9/27


3. – Enrichir un projet

3.1 – Ajouter une structure

L’ajout d’une structure n’est possible que manuellement (contrairement à l’ajout d’une classe –
Cf. chapitre 3.2). L’environnement Visual C++ prend en compte la syntaxe utilisant la
redéfinition d’une structure (typedef struct). Néanmoins, lors de la mise à jour de la
hiérarchie des classes, l’environnement conserve le nom de la structure et pas le nom de la
structure redéfinie (Cf. figure 9).

Déclaration de la structure _Rectangle


et redéfinition en TRect.

ClassView ne prend
pas en compte le nom
de la structure redéfinie

figure 9 – Ajout d’une structure

3.2 – Ajouter une classe

Il existe deux possibilités pour ajouter une classe à un projet :


• éditer le fichier source « .cpp » dans lequel on désire ajouter la classe et écrire le code
manuellement ;
• utiliser le générateur automatique de code source intégré dans Visual C++.

Pour la génération automatique (Cf. figure 10) :


• Cliquer sur l’onglet ClassView ;
• Sélectionner le projet (MonProjet) et cliquer sur le bouton droit de la souris pour obtenir
le menu contextuel ;
• Cliquer sur New Class ;

IGN / ENSG / CPRI Visual C++ - Prise en main page 10/27


Onglet ClassView actif

figure 10 – Ajout d’une classe à un projet

• Entrer le nom de la classe et éventuellement le nom de la (ou des) classe(s) mère(s)


(derived class – Cf. figure 11).

figure11 – Caractéristiques de la classe à ajouter au projet

IGN / ENSG / CPRI Visual C++ - Prise en main page 11/27


Visual C++ génère le code de la classe dans un fichier « nom-classe.h ». Notons qu’il génère
automatiquement les prototypes du constructeur par défaut et du destructeur dans le code de la
classe (Cf – figure 12).
Il génère également un fichier « nom-classe.cpp » contenant le corps du constructeur par défaut
et du destructeur (à remplir par le programmeur - Cf – figure 13).

Code de la classe et du prototype du


constructeur par défaut et du
destructeur

figure 12 – Génération automatique du code de la classe

Code à écrire par le


programmeur

figure 13 – Génération automatique du code du constructeur par défaut et du destructeur

IGN / ENSG / CPRI Visual C++ - Prise en main page 12/27


3.3 – Ajouter une méthode à une classe
Comme pour l’ajout d’une classe à un projet, il existe deux manières d’ajouter une méthode à
une classe : écrire manuellement le code de la méthode ou utiliser l’outil de génération
automatique. Notons que si on ajoute manuellement le prototype d’une méthode dans la
définition de la classe (fichier .h), la mise à jour de la hiérarchie des classes (ClassView)
s’effectue automatiquement.

Pour la génération automatique (Cf. figure 14) :


• Sélectionner la classe ;
• Cliquer sur le bouton droit de la souris pour obtenir le menu contextuel ;
• Cliquer sur « Add Member Fonction ».

figure 14 – Ajout d’une méthode à une classe (génération automatique)

IGN / ENSG / CPRI Visual C++ - Prise en main page 13/27


• Entrer le type de retour et le nom de la fonction ainsi que les éventuels paramètres de la
fonctions (chaque pramètre doit être précédé de son type – Cf. figure 15) ;
• Définir le type d’accès (public, protected ou private - Cf. figure 16).

figure 15 – Caractéristiques de la méthode à ajouter à la classe

Le code (vide) de la méthode ajoutée (void Affiche (int a)) est générée dans le fichier
« nom-classe.cpp », le prototype de la méthode dans le fichier « nom-classe.h » et la hiérarchie
des classes (ClassView) est mise à jour (Cf. figure 16).

Génération automatique de la
méthode Affiche(int a)
Mise à jour de
ClassView

figure 16 – Résultat de l’ajout d’une méthode

IGN / ENSG / CPRI Visual C++ - Prise en main page 14/27


3.4 – Ajouter un champ à une classe
De même que pour l’ajout d’une méthode, on peut ajouter manuellement une variable dans une
classe ou l’ajouter de façon automatique. Notons que si on ajoute manuellement une variable, la
mise à jour de la hiérarchie des classes (ClassView) s’effectue automatiquement.
Pour l’ajout automatique (Cf. figures 17 et 18) :
• Sélectionner la classe ;
• Cliquer sur le bouton droit de la souris pour obtenir le menu contextuel ;
• Cliquer sur « Add Member Variable ».

figure 17 – Ajout d’une variable dans une classe (génération automatique)

• Entrer le type et le nom de la variable ;


• Définir le type d’accès (public, protected ou private).

figure 18 – Nom et type de la variable ajoutée

IGN / ENSG / CPRI Visual C++ - Prise en main page 15/27


La définition de la variable privée (int *tab) est ajoutée dans le fichier « nom-classe.h » et la
hiérarchie des classes (ClassView) est mise à jour. Notons que l’icône est différente suivant le
type d’accès de la variable (Cf. figure 19).

tab est un champ privé


(icône différente)

figure 19 – Résultat de l’ajout d’une variable privée

3.5 – Ajouter/supprimer un fichier dans l’arborescence

Pour ajouter ou supprimer un fichier, cliquer sur l’onglet FileView. Pour ajouter, cliquer sur le
bouton droit de la souris et activer le menu « Add Files to Folder ». Pour supprimer,
sélectionner le fichier et appuyer sur la touche « Suppr » de votre clavier. Notez que le fichier est
uniquement supprimer de l’arborescence (il ne sera plus compilé). Pour le détruire physiquement
il faut le supprimer du disque de manière classique (avec l’explorateur par exemple).

IGN / ENSG / CPRI Visual C++ - Prise en main page 16/27


4. – Fermer un projet

L’opération de fermeture d’un projet est très simple : aller dans le menu Fichier et cliquer sur
« Close Workspace » (Cf. figure 20). Si tous les fichiers du projet ne sont pas sauvegardés,
Visual propose de les enregistrer.

figure 20 – Fermer un projet

IGN / ENSG / CPRI Visual C++ - Prise en main page 17/27


5. – Ouvrir un projet existant
Aller dans le menu Fichier, cliquer sur « Open Workspace » (et non Open, Cf. figure 21) et
choisir le projet (fichier « nom-projet.dsw » - Cf. figure 22).

Open permet d’ouvrir


un fichier, pas un projet.

figure 21 – Ouvrir un projet existant

figure 22 – Choix du projet à ouvrir (extension .dsw)

IGN / ENSG / CPRI Visual C++ - Prise en main page 18/27


5. – Les « ++ » de l’éditeur Visual
L’éditeur offre des fonctionnalités intéressantes :
• Placer le curseur de la souris sur le nom d’un type ou d’une variable fait apparaître la
définition de ce type ou de cette variable dans un petit encadré (Cf. figure 23) ;
• Taper le nom d’une variable de type structure ou le nom d’un objet d’une classe suivi du
« . » (ou de « -> ») fait apparaître l’ensemble des membres de la structure ou de la classe
(Cf. figures 24 et 25). De plus, cliquer sur l’un des membres permet d’obtenir le
commentaire qui figure dans la définition initiale de la structure ou de la classe (ceci devrait
encourager l’ajout de commentaires courts et pertinents ! – Cf. figure 25) ;
• Taper le nom d’une méthode suivi de « ( » fait apparaître l’ensemble des prototypes de la
méthode (nombre de paramètres et type de ces paramètres – Cf. figures 26 et 27).

figure 23 – Fonctionnalité intéressante de l’éditeur Visual

IGN / ENSG / CPRI Visual C++ - Prise en main page 19/27


figure 24 – Fonctionnalité intéressante de l’éditeur Visual

figure 25 – Fonctionnalité intéressante de l’éditeur Visual

IGN / ENSG / CPRI Visual C++ - Prise en main page 20/27


L’environnement propose au
programmeur les deux prototypes
de la méthode Affiche

figure 26 – Fonctionnalité intéressante de l’éditeur Visual

figure 27 – Fonctionnalité intéressante de l’éditeur Visual

IGN / ENSG / CPRI Visual C++ - Prise en main page 21/27


6. – Les principales fonctionnalités du débogueur Visual C++

6.1 – Le menu « Debug »


Le débogueur de Visual est très complet et propose de nombreuses fonctionnalités. Les plus
importantes sont présentées dans ce document.
Pour faire apparaître le menu « Debug », cliquer sur le bandeau supérieur de la fenêtre principale
avec le bouton droit de la souris et sélectionner Debug (Cf. figure 28).

figure 28 – Le menu “Debug”

Le menu suivant apparaît :

L’autre menu indispensable pour le déboguage d’applications est le menu suivant (déjà présent
dans le bandeau supérieur de la fenêtre principale) :

IGN / ENSG / CPRI Visual C++ - Prise en main page 22/27


6.2 - Insertion de points d’arrêt
Un point d’arrêt représente un point du programme où le débogueur suspend son exécution. On
peut en indiquer plusieurs afin d’exécuter un programme en s’arrêtant aux endroits souhaités. A
chaque point d’arrêt, il est possible de consulter l’état des variables.

Pour ajouter un point d’arrêt, il suffit de placer le curseur dans l’instruction où l’exécution doit
s’interrompre et de cliquer sur l’icône Insert/Remove Breakpoint (Cf. figure 29).

La représentation graphique
d’un point d’arrêt

figure 29 – Insertion d’un point d’arrêt

Pour exécuter le programme jusqu’au premier point d’arrêt cliquer sur l’icône Go (Cf. figure 30)

IGN / ENSG / CPRI Visual C++ - Prise en main page 23/27


L’exécution du programme s’arrête au premier
point d’arrêt rencontré. La flèche jaune
représente la prochaine l’instruction à exécuter

figure 30– Exécution d’un programme jusqu’à un point d’arrêt

Après avoir examiné les variables, cliquer de nouveau sur l’icône Go pour exécuter le
programme jusqu’au point d’arrêt suivant.

6.3 - L’exécution du programme en mode “pas à pas”


Pour exécuter le programme instruction par instruction, utiliser l’icône Step Into du menu
“Debug” (Cf. figure 31) :

Cette méthode de débogage s’avère très rapidement fastidieuse car en utilisant ce procédé on
exécute le code de toutes les fonctions (y compris le code des fonctions Windows). Pour éviter le
déroulement de l’intégralité du code, on peut utiliser l’icône Step Over qui permet d’exécuter
pas à pas uniquement le code que nous avons écrit (Cf. figure 31) :

Pour exécuter le programme jusqu’à l’endroit où se trouve le curseur (très rapide et très
pratique), il faut utiliser l’icône Run to Cursor :

IGN / ENSG / CPRI Visual C++ - Prise en main page 24/27


Le mode S t e p Into permet
« d’entrer » dans la méthode Affiche.

figure 31 – Le mode “Step Into”

Exécution « pas à pas » du code

figure 32 – Le mode “Step Over”

IGN / ENSG / CPRI Visual C++ - Prise en main page 25/27


6.4 - Vérification de la valeur des variables
Il est possible de surveiller l’état des variables grâce à la fenêtre située à gauche sous la fenêtre
de l’éditeur (Cf. figure 33). Cette fenêtre comprend trois onglets :
• “Auto” : affiche les variables automatiques utilisées dans l’instruction en cours (désignée
par la flèche jaune) et dans la précédente ;
• “Locals” : affiche la valeur des variables locales à la fonction en cours ;
• “this” : affiche les membre de l’objet courant lorsque le point d’arrêt se trouve au sein d’une
fonction membre d’une classe non statique.

On a passé l’instruction d’affectation


de la valeur r.largeur (qui vaut 4)

figure 33 – L’état des variables

IGN / ENSG / CPRI Visual C++ - Prise en main page 26/27


On peut également visualiser uniquement certaines valeurs grâce à la fenêtre “Watch” (à droite
de la fenêtre précédemment détaillée). Il suffit d’entrer le nom des variables en question (Cf.
figure 34).

La valeur r.largeur vaut 4 et la valeur


r.longueur n’a pas été affectée.

figure 34 – La fenêtre “Watch”

IGN / ENSG / CPRI Visual C++ - Prise en main page 27/27