Étapes de création d`un squelette d`application avec Visual C++

LYCEE FRANCO-MEXICAIN
HOMERO 1521
COLONIA POLANCO
11560 MEXICO, D.F.
Introduction à Visual C++
SOMMAIRE
ÉTAPES DE CRÉATION D’UN SQUELETTE D’APPLICATION AVEC VISUAL C++ .................................3
DÉFINITION D’UN PROJET ...........................................................................................................................................3
DÉFINITION DE L’INTERFACE D’APPLICATION ............................................................................................................5
DÉFINITION DES OPTIONS GÉNÉRALES DIALOG BASED ...............................................................................................6
DÉFINITION POUR SDI/MDI DU SUPPORT DE BASE DE DONNÉES ................................................................................7
DÉFINITION POUR SDI/MDI DU SUPPORT OLE. .........................................................................................................8
DÉFINITION POUR SDI/MDI DES OPTIONS D’INTERFACE ............................................................................................9
DÉFINITION DU COMMENTAIRES DANS LES FICHIERS ................................................................................................10
DÉFINITION DES CLASSES DU PROJET........................................................................................................................11
LISTE DES SPÉCIFICATIONS DU PROJET .....................................................................................................................12
INTERFACE GÉNÉRALE DE VISUAL C++ .......................................................................................................13
PRISE EN MAIN DE L’INTERFACE GÉNÉRALE .............................................................................................................13
LE WORKSPACE .......................................................................................................................................................15
UN PREMIER ESSAI SUR LE SQUELETTE .....................................................................................................................16
COMPILATION, CONSTRUCTION ET DÉBOGAGE.......................................................................................17
TESTER SIMPLEMENT UNE APPLICATION ...................................................................................................................17
DÉBOGUER UNE APPLICATION ..................................................................................................................................18
Entrer dans le mode de débogage .......................................................................................................................18
Utiliser le débogueur...........................................................................................................................................18
L’AIDE SOUS VISUAL C++ ...................................................................................................................................20
LANCEMENT DE RECHERCHES ..................................................................................................................................20
LA CARTE DES CLASSES MFC...................................................................................................................................21
Page 2/22
Introduction à Visual C++
Étapes de création d’un squelette d’application avec Visual C++
Définition d’un projet
Tout d’abord, lancer Microsoft Visual C++ 5 :
Démarrer -> Programmes -> Microsoft Visual C++ 5.0 -> Microsoft Visual C++ 5.0
Ensuite, lancer un nouveau projet : File -> New
L’onglet Projects est automatiquement sélectionné :
Onglets :
Files : pour créer de simples fichiers, ou ajouter des fichiers à un projet en cours,
Projects : pour créer un nouveau projet, on notera entre autres :
MFC AppWizard (dll) : : pour créer rapidement, à l’aide des classes MFC :
Microsoft Foundation Classes, des fichiers Dynamic-Link Library (.dll)
regroupant du code (des objets) à partager entre diverses applications, et
appelé dynamiquement par ces applications lors de leur exécution,
MFC AppWizard (exe) : pour créer des applications rapidement à l’aide des
classes MFC : Microsoft Foundation Classes,
Win32 Application : pour créer une application Windows,
Win32 Console Application : pour créer une application lancée à partir d’une
console,
Page 3/22
Introduction à Visual C++
Win32 Dynamic-Link Library : pour créer des fichiers Dynamic-Link Library
(.dll) regroupant du code (des objets) à partager entre diverses applications, et
appelée dynamiquement par ces applications lors de leur exécution,
Win32 Static Library : pour créer des bibliothèques d’objets pouvant être
appelées lors de la compilation d’un projet,
Workspaces : pour créer un espace de travail vierge, ou en récupérer un personnalisé,
Other Documents : pour créer un document avec une application installée sur la
machine (Word, Excel, …).
Les classes Microsoft MFC facilitent grandement le développement d’applications. En effet,
au lieu d’avoir à connaître sur le bout des doigts les API (Application Programing Interface)
32 bits de Windows, le programmeur peut utiliser une pléthore de classes décrivant des
objets prêts à l’emploi ! Cela simplifie le travail, car ces classes MFC sont immédiatement
réutilisables, et divisent le temps de développement.
Dans l’onglet Projects :
⇒ choisir MFC AppWizard (exe)
⇒ taper un nom de projet : PremierProjet, et contrôler que le chemin de création est celui
souhaité, ou bien le laisser tel quel.
⇒ puis cliquer sur OK.
Page 4/22
Introduction à Visual C++
Définition de l’interface d’application
Le premier écran MFC Appwizard apparaît :
Dans les trois types d’applications, on retrouvera toujours deux classes : celle de
l’application qui s’occupe de lancer l’application, et celle de la trame qui contient les boutons,
barres d’outils, menus, …
Les choix possibles sont les suivants :
Single document : application mono-document où deux classes gérent le document de
travail : une classe de document et une classe d’affichage du document, c’est le cas du
notepad, du wordpad ou de paintbrush…
Multiple document : application multi-documents où aux classes précédentes s’ajoute
une classe de trame fille pour chaque couple {classe de document + classe d’affichage}
de chaque document ouvert (la classe d’affichage peut être la même pour chaque
document ouvert),
Dialog based : application de type boite de dialogue, où la classe d’affichage gère
l’ensemble des éléments affichés, c’est le cas des panneaux de configuration de
Windows, de VNC, …
Cependant, ces configurations sont ensuite pleinement personnalisables (exemple : application
MDI de boites de dialoques…).
Langage : langue utilisée par les classes MFC pour les interfaces utilisateurs du projet.
Selon le type d’application choisi, ce panneau sera suivi :
soit de trois autres écran : pour Dialog based,
soit de cinq autres écrans : pour Single document (SDI), ou Multiple Document (MDI).
Commençons par voir le panneau 2/4 propre aux projets Dialog based.
Sélectionner Dialog based, puis cliquer Next.
Page 5/22
Introduction à Visual C++
Définition des options générales pour Dialog based
Ce panneau comporte les uniques options pour un projet de type Dialog based.
Tout d’abord, nous avons les options d’interface :
About box : crée une classe pour la boite de dialogue A propos
Context-sensitive Help : support de l’aide contextuelle, AppWizard génère un
ensemble de fichier s d’aide , et ce support nécessite le compilateur d’aide.
3D controls : interface visuelle de style 3D.
Puis viennent les options relatives aux objets COM :
Automation : support permettant à des applications de manipuler des objets d’autres
applications, et créer des outils adaptés,
ActiveX : pour intégrer des contrôles ActivesX, c’est à dire des composants logiciels
(anciennement OLE2) dans une application ; ces composants sont fournis avec
VisualC++ ou avec d’autres applications, et il faut les enregistrer auprès de Windows et
de VisualC++ avant de les utiliser.
Enfin nous avons le support des sockets :
Windows Sockets : support des classes MFC destinées à la création et à l’utilisation des
sockets.
Pour finir , un titre peut être donné à la fenêtre de dialogue à créer.
Les deux dernières étapes d’un projet Dialod Based sont identiques à celles des applications
SDI et MDI. Nous les verrons plus tard.
Penchons nous sur les projets SDI et MDI. Donc cliquer sur Back pour revenir au panneau de
sélection du type de projet, puis choisir Multiple document et cliquer Next.
Page 6/22
Introduction à Visual C++
Définition pour SDI/MDI du support de base de données
Ce panneau défini les options de support de bases de données pour le projet, c’est à dire la
possibilité d’intégrer des classes propres à la prise en charge et la manipulation de bases de
données.
Les options sont les suivantes :
none
L’application crée par AppWizard ne comportera pas le fichier d’en-tête afxdb.h,
pour le support de bases de données. L’option par défaut ne prend pas directement
en charge le support de bases de données.
Header files only
L’application fournit un support élémentaire des bases de données.
Database view without file support
La classe de vue de l’application crée par AppWizard est dérivée de CRecordView.
Cette classe est associée à CRecorSet pour gérer les enregistrements
Cette option ne prévoit pas la sérialisation et le menu Fichier, puisqu’elle prévoit une
opération enregistrement par enregistrement, interagissant avec une base de
données.
Ce choix nécessite d’ouvrir la boite SQL Data Source, permettant de spécifier le
type de base de donnée et/ou le fichier ou la table à utiliser.
Database view with file support
Comme précédemment, le support de sérialisation et le menu Fichier en plus !
Laisser le choix par défaut none, puis cliquer sur Next.
Page 7/22
Introduction à Visual C++
Définition pour SDI/MDI du support OLE.
Le support OLE permet d’intégrer ou de créer des éléments partagés s’appuyant sur COM.
Cela permet souvent à des applications d’ouvrir des document d’autres applications de type
OLE (exemple : Excel dans Word, …). Plus généralement, cela permet le partage
d’informations et de services entre processus.
Définition du support d’éléments reposant sur COM :
Les options OLE sont les suivantes :
None : Aucun support OLE,
Container : Pour permettre à l’application de contenir des objets OLE,
Mini-server : Pour permettre à l’application de créer et gérer des objets de documents
OLE. Les serveurs ne peuvent par défaut pas s’exécuter de manière autonome, et ne
supportent que des éléments incorporés,
Full-server : Contrairement au mini-server, le serveur complet peut s’exécuter de
manière autonome, et supporte à la fois les éléments liés et incorporés,
Both container and server : L’application est à la fois container et full-server.
Supports :
Automation : support permettant à des applications de manipuler des objets d’autres
applications, et créer des outils adaptés,
ActiveX : pour intégrer des contrôles ActivesX, c’est à dire des composants logiciels
(anciennement OLE2) dans une application ; ces composants sont fournis avec
VisualC++ ou avec d’autres applications, et il faut les enregistrer auprès de Windows et
de VisualC++ avant de les utiliser.
Laisser la fenêtre en l’état, et cliquer sur Next.
Page 8/22
Introduction à Visual C++
Définition pour SDI/MDI des options d’interface
Ce panneau permet d’intégrer des fonctionnalités d’interface dans l’application (ce qui peut
aussi être aisément fait plus tard). Pour cela, choisir les éléments souhaités parmi les
suivants :
Docking Toolbar : barre d’outil ancrable, contenant par défaut les boutons permettant
de créer, ouvrir et enregistrer des documents, de copier/coller, d’imprimer, d’afficher la
boite de dialogue A propos, et d’invoquer l’aide en ligne.
Initial status bar : barre d’état en bas de la fenêtre, comportant du texte et des
indicateurs pour certaines touches du clavier (verrou majuscules et pavé numérique,
insertion,. …).
Printing and print preview : ajoute au menu Fichier les opérations relatives à
l’impression (Imprimer, Configuration de l’impression et Aperçu avant impression),
Context-sensitive Help : support de l’aide contextuelle, AppWizard génère un
ensemble de fichier s d’aide , et ce support nécessite le compilateur d’aide.
3D controls : interface visuelle de style 3D.
On notera que la barre de menu comportant par défaut les menus Fichiers, Edition, Affichage,
Fenêtre et Aide est intégré d’office à la fenêtre de trame générale.
Autres options :
MAPI (Messaging API) : support des API de messages inter applications.
Windows Sockets : support des classes MFC destinées à l’utilisation des sockets.
Options de fichiers : en cliquant sur Advanced, deux panneaux permettent de configurer
finement le cas échéant les options concernant les fichiers générés par l’application et
l’interface utilisateur dédiée.
Ne rien modifier, et cliquer sur Next.
Page 9/22
Introduction à Visual C++
Définition du commentaires dans les fichiers
En cliquant Yes, cela inclus dans tous les fichiers générés par AppWizard de précieux
commentaires détaillant le rôle de chaque ligne des fichiers .cpp et .h, ainsi que les
emplacements ou le programmeur doit placer son code.
Cela charge un peu les fichiers sources, mais n’influe en rien sur le code objet généré !
Cliquer sur Next.
Page 10/22
Introduction à Visual C++
Définition des classes du projet
Ce panneau permet :
de changer les noms des classes,
de changer les noms des fichiers d’implémentation .cpp et d’en-tête .h associés à
chaque classe,
de changer la classe de base de la classe d’affichage générée pour le projet par
AppWizard.
Avant de cliquer sur Finish, il est possible, comme lors de chaque étape, de cliquer sur Back
pour modifier des choix, en revenant ainsi jusqu’au panneau de projet Projects.
Cliquer sur Finish pour valider les choix effectués dans les panneaux précédents.
Page 11/22
Introduction à Visual C++
Liste des spécifications du projet
Ce panneau détaille l’ensemble des choix effectués au travers des différentes étapes, ainsi que
les opérations que va effectuer AppWizard.
En cliquant sur Cancel, il est encore possible de revenir sur l’étape 4/4 ou 6/6.
Cliquer sur OK afin de créer le squelette d’un éventuel projet.
Page 12/22
Introduction à Visual C++
Interface générale de Visual C++
Prise en main de l’interface générale
L’interface générale se présente sous cette forme :
Workspace
Affichage
Output
L’interface de développement de Visual C++, en dehors de ses menus et barres d’outils,
possède trois zones
Workspace : zone d’affichage des classes, fichiers et ressources,
Affichage : zone d’affichage des fichiers ouverts : sources, aide, etc … ,
Output : fenêtre d’affichage des résultats de compilation, de débugage et de
recherches.
Page 13/22
Introduction à Visual C++
Concernant les menus, leur titre est explicite :
File : création, ouverture, sauv. et fermeture des fichiers, projets et espaces de travail
Edit : copier/coller, recherches et déplacements
View : le fameux Class Wizard (ctrl + W) et autres informations sur le travail en cours
Insert : ajout de classes et ressources au projet
Project : modifications, paramètres et ajout de fichiers et contrôles au projet
Build : compilation, débogage et finalisation du projet
Tools : outils divers de Visual C++, et paramètres généraux du logiciel et de l’interface
Windows : choix d’une fenêtre dans la zone d’affichage
Help : aide (combien précieuse) et ses outils
De nombreuses fonctions des menus se retrouvent dans des barres d’outils dont certaines sont
affichées, les autres étant accessibles avec Tools -> Customize.
Page 14/22
Introduction à Visual C++
Le Workspace
Cette fenêtre représente le pilier de l’interface de développement de Visual C++. Il s’agit
d’une fenêtre qui possède quatre onglets :
ClassView : Fenêtre d’affichage des classes.
Par menus contextuels, il est possible d’ajouter plusieurs classes au projet, et des
fonctions, variables et autres éléments aux classes. Il est à noter que cette vue par
classe est distincte des fichiers. En effet, plusieurs classes peuvent résider dans un
même fichier. Les classes ouvertes apparaissent dans la zone d’affichage dans leur
fichier d’appartenance : celui d’en-tête en double cliquant sur une classe, et celui
d’implémentation en double cliquant sur une fonctions ou une variable.
RessourceView : Fenêtre d’affichage des ressources.
Elle permet de lister et modifier, compléter, ajouter, supprimer les éléments
suivants : raccourcis clavier, boites de dialogue, icônes, menus, constantes, barres
d’outils, version, par menus contextuels. Les éléments ouverts apparaissent dans la
zone d’affichage.
FileView : Fenêtre d’affichage de l’ensemble des fichiers participant au projet.
En double cliquant sur un fichier, il s’ouvre dans la zone d’affichage.
InfoView : Fenêtre d’aide, de présentation et d’accompagnement, indépendante du
projet.
Page 15/22
Introduction à Visual C++
Un premier essai sur le squelette
Avant d’aller plus loin, effectuer ctrl + F5 pour exécuter l’application PremierProjet en mode
Debug (par défaut). Comme l’application n’est à priori exempte d’erreurs, le mode Debug ne
devrait pas se lancer et notre application tourner parfaitement :
Essayer les différentes fonctions des menus et barres d’outils. Il est entre autres déjà possible
d’ouvrir plusieurs documents. Mais la plupart des fonctions sont cependant inopérantes, car
vides de code ! On peut noter que la fonction impression peut déjà provoquer une sortie
imprimante (vide), et que ? -> A propos affiche bien la boite de dialogue appropriée.
Page 16/22
Introduction à Visual C++
Compilation, construction et débogage.
Tester simplement une application
Le menu permet de compiler, construire / exécuter ou déboguer le projet :
Tout d’abord, Set Active Configuration permet de choisir la configuration pour l’exécution
(ctrl+F5) : version debogueur (valeur par défaut) ou version finale.
Ensuite, en lançant Exécute PremierProjet.exe, cela construit complètement un exécutable
dans le sous répertoire Debug ou Release du projet, puis l’exécute.
Dans le cas de la version Debug, elle ne peut fonctionner que sur le poste de développement,
et intègre les directives d’aide au débogage insérées dans le code source, d’où sa taille plus
importante.
La commande Batch Build permet de réaliser d’un seul coup la construction des deux versions.
Page 17/22
Introduction à Visual C++
Déboguer une application
Entrer dans le mode de débogage
Il existe plusieurs façons de rentrer dans le mode Debug.
Tout d’abord, un click droit (menu contextuel) sur une ligne de programme (fichier.cpp) permet
d’ajouter un point d’arrêt (Breakpoint) qui sera pris en compte dans une exécution en mode
Debug : Insert/Remouve Breakpoint.
Ensuite, lancer Build -> Debug -> Go
et l’exécution de l’application s’arrêtera pour rentrer en mode Debug lorsque la position du
curseur sera rencontrée.
D’autre part, il est possible d’exécuter l’application jusqu’à ce que le débogueur rencontre la
position courante du curseur dans un fichier : se placer dans un fichier .cpp sur la ligne
souhaitée, puis à l’aide du menu Debug, lancer Run to Cursor.
Enfin, il est possible de rentrer directement dans le debogueur en mode pas à pas avec Step
Into.
Utiliser le débogueur
Une fois dans le debogueur, le menu Build devient le menu Debug suivant :
Page 18/22
Introduction à Visual C++
Ce menu permet ne nombreuses choses :
Go : reprendre l’exécution
Restart : redémarrer l’exécution
Stop Debugging : quitter le mode Debug
Step Into : pas à pas détaillé
Step Over : pas à pas sans entrer dans les méthodes appelées
Step Out : pas à pas avec sortie directe vers la méthode appelante
Run to Cursor : exécution jusqu’à la nouvelle place du curseur
Exceptions… et Threads… : visualisation des exceptions possible et des Threads.
QuickWatch : visualisation de l’état de certaines variables.
De plus, il est toujours possible d’ajouter ou retirer des points d’arrêt par menu contextuel.
Tout ce qui a été vu précédemment peut être testé sans crainte sur notre application vide
PremierProjet : Run to cursor, points d’arrêt et mode pas-à-pas, …
Page 19/22
Introduction à Visual C++
L’aide sous Visual C++
Lancement de recherches
L’aide est très riche dans Visual C++, et permet d’obtenir des informations générales comme
spécifiques sur un sujet, une instruction 16 ou 32 bits, une API Windows, une classe MFC, ou
tout sujet d’ordre plus général. On pourra tout de même lui reprocher des exemples parfois
incomplets ou absents, l’insuffisance des applications exemples (dont les sources sont
fournies), et parfois le manque de clarté.
Cette aide permet cependant de prendre pleinement connaissance de l’interface de Visual
C++, d’obtenir des informations générales sur de nombreux sujets, d’avoir une aide complète
sur les instructions Win16 et Win32, et une carte complète des MFC : Microsoft Foundation
Classes, ainsi qu’une présentation générale et le détail des variables et méthodes publiques de
chacune d’entre elles.
Pour effectuer une recherche sur un sujet, une instruction, … ouvrir la fenêtre d’aide :
Help -> Search…
puis taper le mot clef recherché dans l’Index ou faire une recherche Query :
Dans l’Index, une liste des mots clefs en relation avec le mot tapé apparaissent. En double
cliquant sur l’un d’entre eux, une liste des articles relatifs apparaît en bas. Un double click
affichera l’un d’entre eux.
Page 20/22
Introduction à Visual C++
La carte des classes MFC
Par exemple, supposons que nous voulions afficher la table des classes MFC :
Page 21/22
Introduction à Visual C++
Ensuite, un click sur une classe affiche une page de présentation :
En bas de la page de présentation, deux choix sont proposés au minimum :
Base Class Members : liste des variables et méthodes membres publiques ; en
affichant cette liste, il est possible de cliquer sur un variable ou une méthode et d’en
obtenir une description détaillée parfois accompagnée d’informations complémentaires
(structures mises en œuvre, …) et d’exemples.
Hierarchy Chart : retour à la charte des MFC précédente.
Page 22/22