Freekienix.free.fr/docs/vc++/Introduction-a-Visual-C.doc · Web viewMFC AppWizard (exe) : pour créer des applications rapidement à l’aide des classes MFC : Microsoft Foundation

LYCEE FRANCO-MEXICAINHOMERO 1521

COLONIA POLANCO11560 MEXICO, D.F.

Introduction à Visual C++

ÉTAPES DE CRÉATION D’UN SQUELETTE D’APPLICATION AVEC VISUAL C++.................................3

DÉFINITION D’UN PROJET............................................................................................................................................3DÉFINITION DE L’INTERFACE D’APPLICATION.............................................................................................................5DÉFINITION DES OPTIONS GÉNÉRALES DIALOG BASED...............................................................................................6DÉFINITION POUR SDI/MDI DU SUPPORT DE BASE DE DONNÉES................................................................................7DÉFINITION POUR SDI/MDI DU SUPPORT OLE..........................................................................................................8DÉFINITION POUR SDI/MDI DES OPTIONS D’INTERFACE............................................................................................9DÉFINITION DU COMMENTAIRES DANS LES FICHIERS................................................................................................10DÉFINITION DES CLASSES DU PROJET........................................................................................................................11LISTE DES SPÉCIFICATIONS DU PROJET......................................................................................................................12

INTERFACE GÉNÉRALE DE VISUAL C++........................................................................................................13

PRISE EN MAIN DE L’INTERFACE GÉNÉRALE.............................................................................................................13LE WORKSPACE........................................................................................................................................................15UN PREMIER ESSAI SUR LE SQUELETTE.....................................................................................................................16

COMPILATION, CONSTRUCTION ET DÉBOGAGE........................................................................................17

TESTER SIMPLEMENT UNE APPLICATION...................................................................................................................17DÉBOGUER UNE APPLICATION...................................................................................................................................18

Entrer dans le mode de débogage.........................................................................................................................18Utiliser le débogueur............................................................................................................................................18

L’AIDE SOUS VISUAL C++....................................................................................................................................20

LANCEMENT DE RECHERCHES...................................................................................................................................20LA CARTE DES CLASSES MFC...................................................................................................................................21

Page 2/28


É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,

Page 3/28

Introduction à Visual C++ Win32 Console Application : pour créer une application lancée à

partir d’une console,

Page 4/28


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 5/28


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.

Page 6/28

Introduction à Visual C++Sélectionner Dialog based, puis cliquer Next.

Page 7/28


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.

Page 8/28

Introduction à Visual C++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 9/28


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 onlyL’application fournit un support élémentaire des bases de données.

Database view without file supportLa 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 enregistrementsCette 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 supportComme 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 10/28


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.

Page 11/28

Introduction à Visual C++Laisser la fenêtre en l’état, et cliquer sur Next.

Page 12/28


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.

Page 13/28


Ne rien modifier, et cliquer sur Next.

Page 14/28


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 15/28


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 16/28


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 17/28


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 :

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 18/28

Workspace Affichage

Output


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 19/28


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 20/28


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 21/28


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 22/28


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ébogueurUne fois dans le debogueur, le menu Build devient le menu Debug suivant :

Page 23/28


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 24/28


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 :

Page 25/28

Introduction à Visual C++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 26/28


La carte des classes MFC

Par exemple, supposons que nous voulions afficher la table des classes MFC :

Page 27/28


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 28/28