Algorithmique et Programmation I

TP n° 1 : Prise en main de Visual C++

Année universitaire 2008/2009 – Semestre 1

Table de matières
1) Présentation générale 2
2) Création d'un nouveau projet 2
Saisie de code 4
3) Compilation et édition de liens 4
4) Exécution d'un projet 5
5) Configuration d'un projet 5
6) Fermeture d'un projet 5
7) Ouverture d'un projet existant 6
8) Débogage d’un programme 7
Création d’un deuxième projet 7
Tracer un programme 8
Les données 9
9) Quelques raccourcis 10

Prise en main de Visual C++ Page 1 / 11

1) Présentation générale
Le présent document a pour but de vous apprendre très succinctement, la manipulation de Visual C++, en ce
qui concerne la création d'un projet très simple, afin de pouvoir compiler des programmes C.
Visual C++ fonctionne suivant les notions de "Projet" et "Espace de travail", comme désormais la plupart
des environnements de programmation intégrés.
L'espace de travail est l'environnement de développement du programmeur, et est sauvegardé dans un fichier
dès sa fermeture, afin d'offrir à l'utilisateur les mêmes conditions lors de la réouverture. Il faut également
savoir qu'un "Workspace" peut contenir plusieurs projets.
Un projet contient des informations plus techniques relatives à la programmation. C'est dans ce fichier que
seront stockés le nom des fichiers présents, les librairies utiles, etc.

2) Création d'un nouveau projet

Pour créer un nouveau projet (qui fera partie automatiquement d'un espace de travail par défaut), vous devez
choisir le menu File puis New. Attention, le bouton "New" de la barre d'outils n'a pas le même rôle : il
permet de créer seulement un nouveau fichier, mais pas de projet.
Vous arrivez alors devant la boîte de dialogue suivante :

Figure 1: Choix de type de projet

Dans l'onglet "Projects", cliquez sur le 10ème choix de la liste : "Win32 Console Application".
Visual C++ permet en effet d'effectuer de nombreux types de programmes différents, comme par exemple,
des librairies, des applications Windows classiques ou encore des programmes qui s'exécutent en mode
"Dos" (fenêtre Dos).
Vous pouvez alors entrer un nom pour votre projet dans la boîte d'édition "Project Name" ("Exemple 1" dans
l'exemple) et la localisation physique de votre projet sur le disque dur, dans "Location" ("D:\Algorithmique
et Programmation 1\Code\" pour l'exemple).

Prise en main de Visual C++ Page 2 / 11

 Figure 2: Choix de type d'application

Vous pouvez alors appuyer sur "Ok". Visual C++ se charge alors de créer pour vous tout l'environnement de
base, nécessaire à la réalisation de votre programme.
L’étape suivante permet de choisir le type d’application désirée (figure 2). 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.
Cliquer sur le bouton Finish pour générer le projet.

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 et permet ainsi un déplacement très aisé dans le code de l’application. FileView
répertorie les fichiers sources constituant le projet. En "double cliquant" sur un nom de fichier, le contenu
apparaît dans la fenêtre de l’éditeur (figure 3).

Prise en main de Visual C++ Page 3 / 11

 Figure 3: L'espace de travail Visual C++

On note l’inclusion par Visual C++ du fichier stdafx.h. Ce fichier est obligatoire pour la construction du
projet. Tous les #include <fichier.h> doivent impérativement être déclarés après ce fichier système.

Saisie de code
Dans la fenêtre d’édition on écrit le programme suivant :

#include "stdafx.h"
#include <stdio.h>

int main(int argc, char* argv[])

{
printf("Bonjour tous le monde !\n");
return 0;
}

L’instruction #include <stdio.h> permet d’inclure la bibliothèque standard d’entré/sortie affin

d’appeler la fonction printf.

3) Compilation et édition de liens

Il existe deux compilations différentes : soit vous compilez le fichier courant seul ("Ctrl+F7") ou bien le
projet dans sa globalité ("F7"). C'est la deuxième qui permet la génération d'un exécutable, bien entendu.
Il est également toujours possible d'accéder à ces actions, par l'intermédiaire du menu "Build" de l'interface,
ou encore par le bouton correspondant.

Prise en main de Visual C++ Page 4 / 11

Tout en bas vous trouverez un journal de log de la compilation. Il vous dira si la compilation c'est effectuée
avec succès ou bien si il a trouvé des erreurs. Vous pouvez double cliquez sur les lignes d'erreur pour qu'il
vous amène directement à l'erreur dans tel ou tel fichier.

4) Exécution d'un projet

Après avoir compilé le projet, vous pouvez l'exécuter en sélectionnant "Execute Exemple 1.exe" (Ctrl+F5).
Une fenêtre Dos s'affiche alors : elle contient les sorties du programme que vous venez décrire.

Figure 4: Exécution d'un projet

5) Configuration d'un projet

Visual C++ peut compiler votre projet sous deux formes. Soit la forme "Debug" afin de pouvoir au mieux
utiliser le débogage lors d'erreur et la forme "Release" pour la version finale de votre projet. Pour passer de
l'un à l'autre, il faut cliquez sur Configuration dans le menu Build.

Figure 5: Configuration d'un projet

6) Fermeture d'un projet

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

Prise en main de Visual C++ Page 5 / 11

 Figure 6: Fermer un projet

7) Ouverture d'un projet existant

Aller dans le menu File, cliquer sur "Open Workspace" (et non Open) et choisir le projet (fichier "nom-
projet.dsw").

Figure 7: Ouvrir un projet existant

Prise en main de Visual C++ Page 6 / 11

8) Débogage d’un programme

Création d’un deuxième projet

On commence par la création d’un deuxième projet Visual C++ ("Exemple 2") de type "Win32 Console
Application".

Figure 8: Création de projet (Exemple 2)

Dans la fenêtre d’éditeur, on écrit le programme suivant qui permet de saisir 3 entiers, de calculer et
d’afficher leur somme, leur produit et leur moyenne :
#include "stdafx.h"
#include <stdio.h>

int main(int argc, char* argv[])

{
/* Déclaration de variables */
float a, b, c;
float somme, produit, moyenne;

/* Saisie de 3 nombres */
printf("Entrez a : ");
scanf("%f", &a);
printf("Entrez b : ");
scanf("%f", &b);
printf("Entrez c : ");
scanf("%f", &c);

/* Calcul de somme, produit et moyenne */

somme = a + b + c;
produit = a * b * c;
moyenne = somme / 3;

Prise en main de Visual C++ Page 7 / 11

 /* Affichage de résultat */
printf("Somme: %f\n", somme);
printf("Produit: %f\n", produit);
printf("Moyenne: %f\n", moyenne);

return 0;
}

Après, on compile et on exécute le projet. Le résultat est affiché dans la fenêtre suivante :

Figure 9: Exécution de projet (Exemple 2)

Par défaut, Visual C++ compile les projets en mode "Debug". Cela signifie que des informations de
débogage sont incluses dans l'exécutable, afin d'aider le programmeur à retrouver certaines erreurs.
En effet, le programme est alors traçable, c'est-à-dire qu'à tout moment durant l'exécution, il est possible de
savoir où on se trouve dans le code. De même, lors d'un plantage, le debugger pourra rendre la main si on le
désire, exactement à l'endroit où l'erreur a eu lieu. Ceci simplifie bien évidemment grandement la tâche du
développeur.

Tracer un programme
Comme il a été signalé précédemment, il est possible de "tracer" un programme. Cela consiste à l'exécuter
ligne par ligne, expression après expression. Pour ce faire, il y a plusieurs solutions.
a) La première fonctionne suivant la technique des "Breakpoints" : on place un point d'arrêt quelque part
dans le code. Il suffit de placer le curseur dans l’instruction ou l’exécution doit s’interrompre et de
cliquer sur l’icône Insert/Remove Breakpoint (figure 10). On obtient un petit rond rouge sur la gauche
de la ligne de code, qui signifie qu'un breakpoint est présent.

Prise en main de Visual C++ Page 8 / 11

 Figure 10: Insertion d'un point d’arrêt (breakpoint)

On lance alors l'exécution en mode Debug (F5), et le programme s'arrête automatiquement à l'endroit voulu.
Il est alors possible de tracer le programme ligne par ligne (F10 ou F11), ou bien de le relancer jusqu'à la fin
ou le prochain point d'arrêt.
b) Une seconde solution consiste à ne pas mettre de breakpoint, mais à exécuter un programme jusqu'à une
ligne donnée. Cette possibilité est offerte par Visual C++ grâce au menu "Build", "Start Debug", puis
"Run To Cursor" (Ctrl+F10).

Les données
En plus de pouvoir tracer un programme, on peut voir les contenus de données (variables) du programme.
Pour cela, vous pouvez vous servir de la barre qui s'affiche en bas de l'interface de Visual en mode débogage
(figure 11). La partie de droite est notamment très utile pour suivre l'évolution d'une variable lorsque vous
tracez un programme. Pour rajouter une variable dans cette partie, il suffit d'effectuer un glisser-déposer de
cette dernière.

Figure 11: à gauche, les variables et fonctions en cours d'utilisation, à droite, les variables que l'utilisateur
souhaite examiner

Prise en main de Visual C++ Page 9 / 11

Vous pouvez également avoir accès au contenu d'une variable en cliquant sur elle à l'aide du bouton droit de
la souris, puis "Quickwatch".

Figure 12: Quickwatch d'une variable (ici, "a")

9) Quelques raccourcis

Souris
On peut glisser/déposer le texte sélectionné.
-Ctrl (maintenu) : Copier au lieu de déplacer.
-Alt (maintenu) : Sélectionner un rectangle de texte (reste un rectangle quand coupé/collé).
-Clic dans la marge : Sélectionner des lignes.
-Double-clic : Sélection d'un mot.

Déplacement
-Home/End : Aller en début/fin de texte de ligne (répéter Home pour aller en début de ligne,
+Ctrl : Début/fin de fichier).
-Ctrl+Gauche/Droite: Aller de mot en mot.
-Ctrl+E : Aller à l’accolade/parenthèse/crochet apparié.
-Ctrl+J/K : Aller au #if #ifdef #ifndef #else #endif précédent/suivant.
-Ctrl+Shift+F8 : Sélectionner un rectangle de texte au curseur.
+Shift : Sélectionner en déplaçant le curseur avec n’importe laquelle des commandes
précédentes.

Navigation
-Ctrl+F3 : Occurrence suivante du mot courant (+Shift:précédent).
-Ctrl+F2 : Mettre/enlever un marque-page (+Shift:tout enlever).
-F2 : Aller au marque-page suivant (+Shift:précédent).
-F4 ou double-clic : Lignes mentionnées dans la fenêtre output (erreurs ou "Find in Files"),
(+Shift:précédent).

Edition
-Ctrl+L : Couper ligne(s).
-Ctrl+Shift+T : Permuter deux mots.

Prise en main de Visual C++ Page 10 / 11

-Alt+Shift+T : Permuter deux lignes.
-Ins : Permuter les modes insertion/refrappe de texte.
-Alt+F8 : Indenter correctement la sélection.
-Tab : Augmenter l’indentation des lignes sélectionnées (+Shift: diminuer).
-Ctrl+U : Mettre en minuscules (+Shift: majuscules).
-Ctrl+Backspace : Effacer le mot devant.
-Ctrl+Del : Effacer le mot derrière.

Renseignements
-F1 : Aide sur le mot ou le n° d’erreur de compilation sous le curseur.
-F12 : Trouver la définition du nom.
-Ctrl+* (pavé num) : Revenir à la position d’origine.
-Alt+F12 : Renseignements généraux sur le mot.
-Ctrl+Shift+Espace : Afficher le prototype de la fonction (définie) en cours (Ctrl+PgUp/PgDown si
plusieurs).
-Ctrl+T : Information sur le type (normalement automatique).
-Ctrl+Espace : Complétion automatique.
-Alt+Ctrl+T : Lister membres (normalement automatique), ou tout si au niveau global.

Compilation
-Alt+F10 : Appliquer changement de code sans sortir du débogueur.
-Ctrl+F7 : Compiler le source actuel seulement (fichier *.OBJ). C’est plus rapide.

Autres
-Esc : Masquer la fenêtre output (elle revient toute seule si elle change).
-Ctrl+I : Commencer une recherche incrémentielle (taper les premières lettres).

Prise en main de Visual C++ Page 11 / 11