Prise en main de Visual C++ 6.0

Prise en main de Visual C++ 6.0
1) premier programme
Sélectionnez l’icône suivante pour démarrer l’application.
La fenêtre suivante s’ouvre à l’écran.
Pour créer un nouveau projet, cliquez sur le menu File, New :
1
Dans la fenêtre New qui s’ouvre alors sur l’onglet Projects, sélectionnez « Win32 Console
Application », indiquez le répertoire où vous voulez créer votre projet (ici D:\users\dut_info)
puis tapez le nom de votre projet (ici, il s’agit de essai). Un répertoire essai sera créé
automatiquement dans D:\users\dut_info. Cliquez sur OK pour démarrer la création du projet
essai.
La fenêtre suivante s’ouvre. Sélectionnez « an empty project », puis cliquez sur le bouton
Finish.
2
La fenêtre suivante s’ouvre pour vous informer de la création d’un projet vide. Cliquez sur le
bouton OK.
La fenêtre principale de Visual C++ est maintenant la suivante.
3
Sélectionnez l’onglet File View (en bas à gauche) puis cliquez sur le signe + à gauche de
« essai files » pour obtenir :
Nous allons maintenant pouvoir créer un fichier essai.c qui contiendra le programme. Pour
cela, cliquez sur le menu File, New. Dans la fenêtre New qui s’ouvre alors sur l’onglet Files,
sélectionnez « C++ Source File » puis tapez le nom du fichier (essai.c). Il sera
automatiquement ajouté au projet essai. Cliquez sur OK pour créer ce fichier.
Dans la fenêtre de gauche, cliquez sur le signe + à gauche du répertoire « Source Files » pour
voir le fichier créé :
4
La grande fenêtre de droite est un éditeur ouvert sur le fichier essai.c (dont le nom apparaît
entre crochets dans le bandeau bleu). Cliquez dans la fenêtre d’édition, puis saisissez votre
premier programme.
Sauvez votre programme en cliquant sur la disquette qui se trouve dans la barre d’outils. Nous
pouvons maintenant lancer la compilation en cliquant sur le menu Build, Build essai.exe ou
bien en tapant sur la touche F7 du clavier (il s’agit d’un raccourci). Vous pouvez voir dans la
fenêtre inférieure (en bas de la fenêtre principale) :
5
Cette fenêtre contient les messages d’erreur (error) ou les avertissements (warning) renvoyés
par le compilateur. Ici, il n’y a qu’un avertissement que vous pouvez ignorer. Le compilateur
a créé un exécutable essai.exe que nous pouvons lancer en cliquant sur le menu Build,
Execute essai.exe ou bien en appuyant sur les touches Ctrl+F5 du clavier. Une fenêtre console
s’ouvre afin de lancer essai.exe. La console s’ouvre automatiquement puisqu’il s’agit d’une
application Windows non-graphique qui doit donc obligatoirement s’exécuter à l’aide d’un
interpréteur de commande. Le programme a bien affiché « coucou » sur la première ligne,
puis il s’est arrêté. Tapez n’importe quelle touche du clavier pour fermer la console.
2) trouver une erreur de compilation avec Visual C++
Revenez dans l’éditeur et saisissez le programme suivant à la place du programme
précédent :
6
Pendant la saisie, faites attention à ce que l’éditeur soit en mode Insertion et pas en mode
Overstrike. On passe de l’un à l’autre en appuyant sur la touche Insert du clavier. En mode
Overstrike, les trois lettres OVR apparaissent en noir en bas et à droite de la fenêtre
principale. Si vous cliquez au milieu d’un mot puis que vous tapez du texte, celui-ci écrase le
texte existant. En mode Insertion, les trois lettres OVR apparaissent en gris et votre texte
s’insère dans le texte existant. Vous noterez aussi que l’éditeur de Visual C++ vous indique le
numéro de ligne ainsi que le numéro de colonne où se trouve le curseur.
La compilation ne doit plus maintenant donner ni erreur, ni warning.
Visual C++ apporte de nombreuses commodités pour éviter les erreurs de syntaxe. Par
exemple, lorsque vous tapez une fonction dans l’éditeur, Visual C++ vous montre
automatiquement la syntaxe de cette fonction (en fait, il s’agit de son prototype).
7
D’autre part, vous pouvez sélectionner un mot-clé du langage (qui apparaît en bleu dans le
programme) ou bien une fonction dans l’éditeur et appuyer sur la touche F1 du clavier. L’aide
en ligne démarre alors automatiquement. Par exemple, sélectionnez le mot-clé while et
appuyez sur F1. Le navigateur Internet démarre et la fenêtre « Rubriques trouvées apparaît :
Sélectionnez la rubrique « The C while statement » à l’emplacement « C/C++ languages »
puis cliquez sur le bouton Afficher. L’aide en ligne affiche maintenant la page sur le while.
Cette page, en anglais, contient généralement un exemple d’utilisation.
8
La documentation en ligne est le premier endroit où vous devez chercher l’information qui
vous manque. Introduisons maintenant une erreur dans notre programme en supprimant le ; à
la fin de la ligne 10 (i = 1;). Le compilateur indique maintenant l’erreur suivante ( ;
manquant avant somme) :
Si vous double-cliquez sur le message d’erreur, un curseur bleu va automatiquement se placer
sur la ligne correspondante dans l’éditeur.
Vous noterez que l’erreur a été vue sur la ligne qui suit le ; manquant. Pour obtenir plus d’aide
sur cette erreur, vous pouvez sélectionner le code de l’erreur, puis appuyer sur F1.
L’aide en ligne vous explique alors à quoi correspond cette erreur. Cette méthode marche de
la même manière avec les avertissements.
9
Les erreurs de compilation ne sont hélas pas toujours aussi facile à trouver. Si par exemple
vous oubliez l’accolade après le while ligne 12, les messages sont les suivants :
Le compilateur est alors complètement perdu parce qu’une paire d’accolades est déséquilibrée
et qu’il n’y a plus autant d’accolade ouvrante ({) que d’accolade fermante (}). Il ne voit
l’erreur que sur la dernière ligne (celle du printf), ce qui ne nous indique pas grand chose.
Double-cliquer sur un des messages ne vous donne pas non plus beaucoup d’information.
Dans ce cas, il n’y a pas vraiment de méthode logique pour trouver l’erreur de compilation.
Les erreurs d’équilibrage (accolades {} ou bien parenthèses()) sont les plus difficiles à
découvrir. Mais en utilisant l’indentation dans vos programmes, il devient facile de les éviter.
L’éditeur vous propose une aide pour vérifier à quelle accolade ouvrante correspond une
accolade fermante (cela marche aussi avec les parenthèses). Il suffit pour cela de placer le
curseur près de l’accolade puis d’appuyer sur les touches Ctrl+E du clavier. Le curseur se
déplace alors automatiquement vers l’accolade inverse correspondante.
10
En règle générale, il faut toujours commencer par corriger la première erreur dans la liste
(quand il y a plusieurs messages d’erreur).
Notes importantes
I) La présence d’une erreur de compilation empêche la création du programme
exécutable ce qui empêche donc la mise au point (le debug).
II) Les warnings étant rarement un bon signe, il est préférable de les éliminer. Un
programme correctement écrit ne contient généralement pas de warning.
3) debugger un programme avec Visual C++
Ce n’est pas parce que le programme est écrit et compilé sans erreurs ni warnings qu’il
fonctionne comme prévu. Quand le programme ne s’exécute pas comme vous l’auriez
souhaité, il faut passer à la phase de mise au point (le debug). Pour cela, Visual C++ offre un
debugger intégré très pratique à l’usage. Voyons son fonctionnement avec le programme
précédent. Placez le curseur sur la ligne 7 de l’éditeur (avant le printf) puis cliquez avec le
bouton droit de la souris. Le menu contextuel suivant apparaît :
Cliquez sur « Insert/Remove Breakpoint » pour insérer un point d’arrêt dans votre programme
(ou bien appuyez sur la touche F9 du clavier). Il apparaît en rouge dans la colonne de gauche
de l’éditeur.
11
Lorsque vous lancez le programme avec F5, une fenêtre console s’ouvre. Le programme
commence son exécution puis s’arrête sur le premier point d’arrêt rencontré. Vous êtes alors
dans le debugger. La fenêtre principale de Visual C++ est maintenant séparée en trois zones :
l’éditeur, la zone de visualisation des variables locales (en bas à gauche) et la zone Watch (en
bas à droite).
La flèche jaune dans la colonne de gauche de l’éditeur indique la ligne qui va être
prochainement exécutée. Ici, elle se trouve sur le point d’arrêt, ce qui est normal puisque le
programme s’est arrêté à cet endroit. Nous pouvons maintenant avancer dans le programme
en mode pas à pas. Cliquez sur le menu Debug, Step over ou bien sur l’icône
appuyez sur la touche F10 du clavier.
12
ou encore
La flèche jaune a avancé d’une ligne et l’instruction printf a été exécutée comme vous pouvez
le voir dans la console.
Appuyez à nouveau sur F10. La flèche n’avance pas et les icônes d’avancement pas à pas
deviennent grises :
C’est normal car vous êtes en train d’exécuter un scanf. Cette fonction attend une saisie au
clavier. Il faut donc faire apparaître la console et saisir une valeur :
Au moment où vous tapez sur la touche « Entrée », la fenêtre de Visual C++ re-apparaît au
premier plan. La flèche a avancé d’une ligne.
13
Dans la fenêtre inférieure gauche, cliquez sur l’onglet « Locals ». Vous pouvez voir que le
contenu de N vaut maintenant 5 :
Avançons de deux lignes (F10, F10). Le curseur pointe sur le while,
et toutes les variables sont initialisées.
La valeur de la variable qui vient de changer apparaît en rouge.
14
Vous pouvez voir le contenu de ces variables en hexadécimal. Pour cela, placez le curseur de
la souris dans la fenêtre contenant les variables, cliquez avec le bouton droit de la souris puis
sur « Hexadecimal Display ».
Toutes les variables s’affichent maintenant en hexadécimal.
Pour revenir en décimal, refaites la même opération. Vous pouvez à tout moment interrompre
le mode debug en cliquant sur l’icône « Stop Debugging »
. Vous retrouvez alors l’aspect
normal de la fenêtre de Visual C++. Vous pouvez à tout moment continuer l’exécution du
programme en cliquant sur l’icône « Go »
(ou sur F5). Le programme s’exécute alors
jusqu’au point d’arrêt suivant ou jusqu’à la fin s’il n’y en a plus. La console se ferme alors
automatiquement. Pour supprimer un point d’arrêt, placer le curseur sur la ligne où il se
trouve, cliquez avec le bouton droit de la souris puis cliquez sur « Remove Breakpoint » dans
le menu contextuel qui apparaît. Notez bien qu’un nombre quelconque de point d’arrêt peut
être placé dans un programme.
15
Vous pouvez grâce au debugger voir l’évolution de la valeur de vos variables en exécutant
votre programme pas à pas. Mettez par exemple un point d’arrêt sur le while, puis lancez le
programme avec F5 (n’oubliez pas de taper une valeur dans la console, le programme étant
bloqué sur le premier scanf). Exécutez ensuite le programme en mode pas à pas (avec F10)
pour voir vos variables évoluer à chaque tour dans le while. Vous pouvez à tout moment
connaître la valeur d’une variable de votre programme en plaçant le curseur de la souris sur le
nom de cette variable (ici par exemple, la variable somme) ou encore en sélectionnant le nom
de la variable et en plaçant le curseur sur la sélection :
De la même manière, vous pouvez voir la valeur d’une expression en la sélectionnant puis en
plaçant le curseur de la souris sur cette sélection (ici, l’expression somme + i) :
Si vous êtes en mode hexadécimal, toutes les variables et expression apparaissent en
hexadécimal.
En mode debug, vous pouvez rajouter différentes fenêtres sous la fenêtre d’édition. Pour cela,
placez le pointeur de la souris sur la ligne horizontale qui sépare les zones (le curseur change
d’apparence) puis cliquez avec le bouton droit de la souris :
16
La partie supérieure du menu contextuel vous indique les fenêtres qu’il est possible de faire
apparaître. Il suffit de cliquer sur la ligne pour que la fenêtre apparaisse (si elle n’existe pas)
ou disparaisse (si elle existe). Seules les fenêtres Watch, Variables et Memory nous
intéressent pour l’instant. Nous avons déjà vu la fenêtre Variables qui permet de visualiser le
contenu des variables locales. Vous ne pouvez pas ajouter ou retirer de variables dans cette
fenêtre. Par contre, vous pouvez modifier la valeur d’une variable en double cliquant dans le
champ Value de la variable, puis en tapant une nouvelle valeur. La prise en compte est
immédiate.
La fenêtre Watch (évaluation) est beaucoup plus puissante car elle permet d’évaluer n’importe
quelle expression qu’elle existe ou non dans votre programme. Vous pouvez :
• Soit sélectionner une variable ou une expression dans votre programme puis la tirer dans la
fenêtre Watch. Vous pouvez alors modifier sa valeur comme dans la fenêtre Variable.
• Soit taper directement une expression. Pour cela, double-cliquez dans un champ Name vide
17
puis tapez l’expression à évaluer.
En mode pas à pas, cette expression évolue avec les variables qui la compose. Pour
supprimer une expression en cours d’évaluation, il suffit de sélectionner la ligne puis de
taper sur la touche Suppr du clavier.
La fenêtre Memory permet de visualiser n’importe quelle emplacement dans la mémoire
virtuelle associée au programme, c’est-à-dire de l’adresse 0 (0x00000000) à l’adresse 232-1
(0xFFFFFFFF) sous Windows. Lorsque la fenêtre apparaît, on obtient :
Vous pouvez déplacer la fenêtre Memory en cliquant dans son bandeau bleu puis en plaçant le
rectangle obtenu entre les deux fenêtres Watch et Variables comme sur la figure suivante :
18
Il suffit maintenant de taper une adresse dans le champ Address de la fenêtre Memory pour
voir le contenu de la mémoire virtuelle à partir de cette adresse (ici, 0x0012FF78).
La fenêtre Memory comprend trois champ d’affichage : les adresses, les données sous forme
hexadécimale et les données sous forme de code ASCII. L’adresse à gauche de la ligne
correspond à l’adresse du premier octet de donnée de la ligne. Les octets suivants se trouvent
une case mémoire plus loin. Pour cet exemple, si on prend la première ligne, on trouve :
19
adresse
donnée
0x0012FF78
04
0x0012FF79
03
0x0012FF7A
02
0x0012FF7B
01
0x0012FF7C
04
Le premier octet de la ligne suivante (00) se trouve donc bien à l’adresse 0x0012FF7D (c’est
à dire 0x0012FF78 + 5).
Cette possibilité de voir le contenu de la mémoire est très commode quand on utilise les
pointeurs. A titre d’exemple, vous pouvez faire les opérations suivantes :
1. Visualiser l’expression &i dans la fenêtre Watch (&variable indique l’adresse de la
variable). Ici l’adresse de i vaut 0x0012FF7C.
2. Tapez cette adresse dans la fenêtre Memory.
3. Vérifier la valeur de i en comparant avec la valeur indiquée dans la fenêtre Variables.
La variable i est un entier 32 bits codé sur 4 octets dont la valeur vaut 4, soit 0x00000004 en
hexadécimal. On voit bien que l’octet de poids faible se trouve à l’adresse 0x0012FF7C et que
les trois octets suivants se trouvent au-dessus dans la mémoire.
Vous pouvez changer le nombre d’octets par ligne en changeant la largeur de la fenêtre. On
essaye généralement d’obtenir un multiple de 4 car c’est plus commode pour lire les entiers.
20
4) les fonctions
Il est courant d’utiliser des fonctions dans un programme en C comme dans l’exemple
suivant :
Lancé avec F5, le programme s’arrête sur la ligne 7, juste avant l’appel de la fonction
puissance().
En cliquant sur le bouton « Step Over »
(ou bien en appuyant sur la touche F10), vous
passez à la ligne suivante sans rentrer dans la fonction (mais celle-ci est quand même
exécutée) :
21
alors qu’en cliquant sur le bouton « Step Into »
(F11), vous pouvez entrer en mode pas à
pas dans la fonction :
Une fois que vous êtes dans une fonction, vous pouvez toujours utiliser le mode pas à pas
(« Step Out » ou « Step Over » à votre convenance). Si vous souhaitez arrêter le mode pas à
pas et sortir de la fonction, il suffit de cliquer sur la touche « Step Out »
22
.
Si vous utilisez le « Step Into » avec la fonction printf(), vous allez voir la définition de cette
fonction, ce qui n’a rien de particulièrement intéressant.
Il est donc préférable d’utiliser « Step Over » pour ne pas rentrer dans les fonctions standards
du C et « Step Into » pour rentrer dans vos fonctions. Il est à noter qu’un point d’arrêt peut
être placé n’importe où dans un programme, y compris à l’intérieur d’une fonction. Vous avez
aussi la possibilité avec la touche « Run to Cursor »
d’exécuter votre programme jusqu’à
une certaine ligne. Pour cela, cliquez sur une ligne dans votre fichier source pour y placer le
curseur puis cliquez sur « Run to Cursor ».
Les variables locales ne peuvent être observées que lorsque vous êtes dans la fonction où elles
sont définies. Par exemple, vous pouvez voir le contenu de l’entier n dans la zone Watch tant
que vous êtes dans la fonction main().
23
Par contre, dès que vous rentrez dans la fonction puissance(), n cesse d’être visible (voir : le
message d’erreur dans la zone Watch).
Il se produit le même phénomène pour les variables locales de la fonction puissance() comme
i et puis.
5) les pointeurs et les tableaux
Sous Visual C++, les pointeurs sont manipulés comme les autres types de variables. Prenons
l’exemple du programme suivant :
24
Après lancement avec F5, nous allons placer dans la zone Watch les variables &n, ptri1, &p
et ptri2 (en les sélectionnant dans le source puis en les tirant dans la zone) :
Les pointeurs sur entier ptri1 et ptri2 sont maintenant visibles. En cliquant sur le signe +
à gauche des pointeurs, nous découvrons la valeur pointée :
Comme nous avons mis un point d’arrêt au début du programme, les pointeurs ne sont pas
encore initialisés, ce qui explique les messages d’erreurs. Après deux « Step Over »,
25
prti1 contient l’adresse de n et pointe sur la valeur contenue par n et prti2 contient
l’adresse de p et pointe sur la valeur contenue par p.
Dans le cas où vous utiliseriez un tableau comme dans l’exemple suivant :
Vous pouvez voir le contenu du tableau tab en procédant de la manière suivante. Lancez le
programme avec F5 puis tirez le nom du tableau dans la fenêtre Watch et cliquez sur le
signe + :
26
Le contenu des 6 cases du tableau apparaît. Il est encore non initialisé puisque le point d’arrêt
se trouve au début du programme. A chaque fois que vous cliquerez sur « Step Over », vous
verrez le tableau se remplir, la dernière valeur modifiée apparaissant en rouge.
27
Vous pouvez aussi visualiser le contenu d’une case particulière du tableau en saisissant cette
case dans la zone Watch :
Vous pouvez aussi voir le contenu du tableau directement dans la mémoire en faisant
apparaître la zone Memory et en tapant l’adresse du tableau dans le champ Address :
A chaque activation de « Step Over », vous verrez le tableau se remplir dans la zone Watch et
les 4 octets correspondant à la valeur entière apparaîtront dans la mémoire.
28
6) passage de paramètres sur la ligne de commande
Sous Visual C++, la console est ouverte automatiquement au moment du lancement du
programme (avec Ctrl+F5 par exemple). Il est donc impossible de passer des paramètres à la
fonction main() au moment du lancement. Pour passer des paramètres sur la ligne de
commande, il faut procéder de la manière suivante. Prenons le programme suivant comme
exemple :
Pour spécifier les paramètres à passer, cliquez sur :
Sélectionnez l’onglet Debug dans la fenêtre qui apparaît :
29
Tapez les paramètres in.txt et out.txt dans la case « Program arguments » :
puis cliquez sur OK. Placez un point d’arrêt sur la ligne contenant le if puis lancez le
programme essai en appuyant sur F5 :
30
En plaçant argc et argv dans la zone Watch, vous pouvez constater que les paramètres ont
bien été passés.
Vous pouvez maintenant avancer en mode pas à pas et vérifier que in.txt a bien été copié dans
le tableau InFileName et que le pointeur OutFileName contient l’adresse de argv[2].
Le programme essai affiche comme prévu dans la console :
31
7) emplacement des fichiers
Voyons maintenant l’emplacement des fichiers dans un projet Visual C++. Lors de la création
du projet suivant (essai) :
Les répertoires suivants sont créés sur le disque dur :
Dans cet exemple, le projet essai a été créé dans le répertoire c:\temp. Le répertoire essai
contient (entre autres) le fichier source essai.c et le répertoire Debug contient l’exécutable
essai.exe (que vous pouvez d’ailleurs lancer à la main en ouvrant une console en dehors de
Visual C++). Par défaut, les créations et les ouvertures des fichiers utilisateur se font dans le
répertoire du projet (ici, c:\temp\essai). Par exemple, si vous lancer le programme :
32
Le fichier sortie.txt va être créé dans le répertoire essai.
Si vous souhaitez modifier le répertoire où les fichiers sont ouverts, il suffit de cliquez sur
Project, Settings puis de sélectionner l’onglet Debug.
Tapez le nom du nouveau répertoire dans la case Working directory puis cliquez sur OK.
Dans notre exemple, le fichier sortie.txt est maintenant créé dans le répertoire c:\temp :
33
34