Programmation Windows : environnement

Transcription

Traitement de données
Programmation Windows : L’environnement
Définition d’un projet
Tout d’abord, lancer Microsoft Visual C++ 6 puis lancer un nouveau projet : File > New
L’onglet Projects est automatiquement sélectionné :
On dispose de plusieurs 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, des fichiers DLL (DynamicLink Library) 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 Win32
Application : pour créer une application Windows,
Win32 Console Application : pour créer une application lancée à partir d’une console,
Win32 Application pour créer des applications sans utiliser l’assistant AppWizard.
Win32 Dynamic-Link Library : pour créer des fichiers DLL regroupant du code à 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, …).
On utilisera, de préférence, les classes MFC qui 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.
#Niedercorn LT « la Briquerie » 57100 THIONVILLE
Programmation Windows : environnement & page 1/15
Créer un projet vierge
C'est la plus simple des opérations, elle consiste tout simplement à vous créer un projet vierge dans lequel vous
ajouterez votre code. Pour ce faire, sélectionnez l'option New dans le menu File. Ensuite, sélectionnez l'item
Win32 application et entrez un nom pour votre projet (je vous suggère Projet1, afin que vous ne soyez pas
obligé de modifier le code source présenté un peu plus bas). Votre fenêtre doit maintenant ressembler à la
Figure :
Cliquez ensuite sur OK. Voilà vous venez de créer un espace de travail vierge pour votre premier programme
en Visual C++. Il reste une dernière chose à faire avant de passer au point suivant.
On doit spécifier à notre projet que nous désirons utiliser les Microsoft Foundation Classes (MFC).
Donc, pour dire à votre projet d'utiliser les MFC, sélectionnez l'option Settings... dans le menu Project. Par
défaut les 'Microsoft Foundation Classes' sont à 'Not Using MFC', sélectionnez alors dans le combo 'Use MFC
in a Shared DLL', ce qui signifie que les MFC ne seront pas incluses dans votre exécutable mais seront appelés
à partir d'un DLL. Votre fenêtre doit maintenant ressembler à la Figure :
Cliquez sur OK. Votre programme pourra maintenant être en mesure d'utiliser les MFC. Visual C++ propose
également un assistant (MFC AppWizard) pour la création d'un projet qui permet de créer une application de
base (fenêtre principale, menu, toolbar, etc.) sans que vous ayez à coder quoi que ce soit, mais dans notre cas il
ne serait pas utile d'utiliser cet assistant puisque notre but est d'apprendre comment programmer avec Visual
C++. Il est préférable pour nous d'écrire nous même le code afin de bien le comprendre. Une fois plus à l'aise
avec la programmation orientée-objet en C++, rien ne vous empêche d'utiliser AppWizard, ce qui vous fera
probablement gagner du temps. Pour l'instant je préfère ne pas l'utiliser afin de bien comprendre l'ensemble du
code.
Les fichiers à créer.
Notre but est de créer une fenêtre Windows 'vide', pour ce faire, le minimum nécessaire pour réaliser cela est de
créer 3 fichiers d'en-tête et 3 fichiers de code source.
Ces fichiers sont les suivants:
StdAfx.h
StdAfx.cpp
Projet1.h
Projet1.cpp
MainFrame.h
MainFrame.cpp
En C++, les fichiers d'en-tête (.h) servent à contenir les déclarations de classes, quant aux fichiers .cpp ils
contiennent le code proprement dit des classes.
Création des fichiers StdAfx.h et StdAfx.cpp
Les deux premiers fichiers, soit StdAfx.h et StdAfx.cpp, ne contiennent pas vraiment de code. Ils se contentent
d'inclure les déclarations de fonctions globales utilisées et ce afin d’accélérer la compilation (on aurait pu
déclarer ces inclusions directement dans le fichier source principal).
Pour créer ces fichiers ou tout autre avec Visual C++, il suffit, à partir du menu File de sélectionner l'option
New et ensuite C/C++ Header File avec le nom du fichier (dans notre cas StdAfx). Cela créera un fichier d'entête vierge. Vous procéderez de la même façon pour le fichier .cpp mais en sélectionnant l'option C++ Source
File cette fois.
Ces fichiers seront automatiquement ajoutés à votre projet Visual C++.
StdAfx.h
// Ce sont des commandes du préprocesseur, pour la
// compilation conditionnelle qui permettent de ne pas
// inclure plus d'une fois ce fichier dans l'exécutable.
// (if not define).
#ifndef __STDAFX_H__
#define __STDAFX_H__
// Inclusions de librairies de fonctions globales MFC
#include <afxwin.h>
#include <afxext.h>
// Fin du bloc pour la compilation conditionnelle.
#endif
StdAfx.cpp
// Inclusions du fichier .h
#include "StdAfx.h"
On inclut tout simplement les fichiers header AfxWin.h et AfxExt.h qui contiennent les déclarations de plusieurs
fonctions globales des MFC.
Par fonctions globales, vous pouvez comprendre que ce ne sont pas des fonctions membres appartenant à un
objet, ce sont des fonctions pouvant être appelés à n'importe quel endroit de votre code.
Par exemple, une fonction des Afx se nomme AfxMessageBox. Cette fonction peut-être appelée pour afficher
une boîte de dialogue et n'attend aucun « handle » de fenêtre en paramètre. La fonction API MessageBox quant
à elle a absolument besoin qu'ont lui transmettre un handle de fenêtre (hwnd).
Quant à vous parler des fonctions APIs, je tiens à souligner une différence par rapport à la fonction
MessageBox des APIs et la fonction membre MessageBox appelée par les MFC. Comme je l'ai dit plus haut, la
fonction MessageBox des APIs doit absolument recevoir un handle de fenêtre en paramètre, mais pas la
fonction membre des MFC.
Pourquoi ? Parce que la fonction membre des MFC provient de la classe CWND et dans cette classe il existe
une variable membre public appelée m_hwnd qui est initialisée à la construction de l'objet. C'est pourquoi vous
n'avez pas à lui transmettre le handle de fenêtre puisque la fonction membre utilise implicitement cette variable.
Si vous le désirez vous pouvez toujours appeler MessageBox des APIs en lui passant m_hwnd. Pour appeler la
fonction API vous devez par contre utiliser le symbole :: juste devant le nom de la fonction; comme ceci :
Appel de la fonction MessageBox API
::MessageBox(m_hwnd, "Votre texte", "Le titre ", MB_OK)
Alors que pour appeler la fonction membre MessageBox des MFC vous faite comme ceci:
Appel de la fonction MessageBox MFC
MessageBox("Votre texte", "Le titre ", MB_OK)
Bien sûr, cela ne s'applique pas qu'à cette fonction, ce n'est qu'un exemple parmi tant d'autres.
Création des fichiers Projet1.h et Projet1.cpp
Maintenant, nous allons créer les deux fichiers Projet1. Habituellement en C++, un fichier créé correspond à
une classe (son fichier d'en-tête et le code source de la classe), nous allons donc suivre cette habitude en créant
un nouveau fichier à chaque nouvelle classe que nous désirons créer. Rien ne vous empêche par contre de
programmer plus d'une classe par fichier, mais il est beaucoup plus facile de se repérer lorsque chaque fichier
correspond à une classe.
La classe que nous allons créer est dérivée de la classe MFC CWinApp. CWinApp est une classe de base de
laquelle on dérive toute application Windows qui utilise les MFC. Voici donc la déclaration de notre classe
Projet1App:
Projet1.h
#ifndef __PROJET1_H__
#define __PROJET1_H__
// Déclaration de la classe CProjet1App
// La classe CProjet1App dérivé de la classe CWinApp
// des MFC
class CProjet1App : public CWinApp {
// Constructeur/Destructeur
public:
CProjet1App();
Virtual ~CProjet1App();
// Méthodes publics
// InitInstance est une fonction membre surchargé.
public:
virtual BOOL InitInstance();
// Déclaration de la tables des messages
protected:
DECLARE_MESSAGE_MAP()
};
#endif
Projet1.cpp
// Inclusions
#include "StdAfx.h"
#include "Projet1.h"
#include "MainFrm.h"
// MFC Debugging Support
#ifdef _DEBUG
#undef THIS_FILE
static char BASED_CODE THIS_FILE[] = __FILE__;
#endif
// Variables globales
//--------------------------------------------------------CProjet1App theApp;
// Liste des messages
//--------------------------------------------------------BEGIN_MESSAGE_MAP(CProjet1App, CWinApp)
END_MESSAGE_MAP()
// Constructeur/Destructeur de CProjet1App
//--------------------------------------------------------CProjet1App::CProjet1App()
{
}
CProjet1App::~CProjet1App()
{
}
// Méthode public
//--------------------------------------------------------BOOL
CProjet1App::InitInstance()
{
// Création de la fenêtre principale.
// Création d'un objet CmainFrame et conservation adresse
// dans la donnée membre m_pMainWnd.
m_pMainWnd = new CmainFrame;
// Vérification que le pointeur n'est pas égal à NULL
ASSERT(m_pMainWnd);
if (((CmainFrame*)m_pMainWnd)->Create(m_pszAppName))
{
m_pMainWnd->ShowWindow(m_nCmdShow);
m_pMainWnd->UpdateWindow();
return TRUE;
}
return FALSE;
}
Votre projet "projet1" est prêt. Vous y trouvez des classes et des fichiers.
On peut compiler et exécuter pour voir la fenêtre.
Créer un projet avec un assistant.
On peut aussi pour une application, utiliser l’assistant, par exemple, pour une application utilisant les MFC:
Définition de l’interface d’application
Le premier écran MFC Appwizard apparaît et propose 3 types d’applications :
Dans les 3 types d’applications, on retrouvera toujours deux classes : celle
de l’application qui s’occupe de lancer l’application, et celle de la gestion
des messages (boutons, 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.
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.
Une fois choisie, ces configurations sont ensuite pleinement personnalisables. L’option Langage détermine la
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 3 autres écrans : pour Dialog based,
soit de 5 autres écrans : pour Single document (SDI), ou Multiple Document (MDI).
Le cas des projets Dialog based.
Sélectionner Dialog based, puis cliquer Next.
Ce panneau comporte les uniques options pour un projet de type
Dialog based.
Tout d’abord, nous avons les options d’interface :
1. About box : crée une classe pour la boite de dialogue A
propos
2. Context-sensitive Help : support de l’aide contextuelle,
AppWizard génère un ensemble de fichiers d’aide, ce
support nécessite le compilateur d’aide.
3. 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 Actives X, c’est à dire des composants logiciels (anciennement
OLE2) dans une application ; ces composants sont fournis avec Visual C++ ou avec d’autres
applications, et il faut les enregistrer auprès de Windows et de Visual C++ 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.
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.
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.
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.
Les 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.
Laisser la fenêtre en l’état, et cliquer sur Next.
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 fait
aisément 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 fichiers
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.
Définition des 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.
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.
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.
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.
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.
Le Workspace
Cette fenêtre représente le pilier de l’interface de développement de Visual C++. Une fois choisie les options
avec AppWizard, on peut, grâce à lui, observer notre projet et vérifier notre environnement, on y trouve (par
exemple) :
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.
Par exemple :
CTestApp : Le point d'entrée de votre appli. Hérite de CWinApp.
CAboutDlg : Petite boîte de dialogue affichant le "à propos" de l'appli. Hérite de CDialog.
CMainFrame La fenêtre principale de votre appli. Hérite de CFrameWnd.
CTestDoc : Le document (unique) de votre appli. Hérite de CDocument.
CTestView : La vue principale de votre appli. Hérite de CView.
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.
Par exemple :
Accelerator : Contient les raccourcis clavier pour l'appli.
Dialog : Contient les fenêtres de l'appli. C'est le coin "design".
Icon : Dessinez des icônes pour votre appli.
Menu : Contient les menus de votre appli.
String Table : Contient les chaînes de caractères pour les messages dans les fenêtres.
Toolbar : Contient la toolbar (une image) de votre appli.
Version : Contient des infos de version de votre appli (cf message de "à propos").
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.
Test et mise au point.
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 boîte
de dialogue approprié.
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.
Déboguer une application
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 :
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, …
Vous pouvez tester le programme - Exécuter (Ctrl+F5) :
Afin de comprendre comment ça démarre, voilà la liste chronologique des méthodes appelées au démarrage de
l'application :
CTestApp::CTestApp()
CTestApp::InitInstance() // crée les Doc, MainFrame, View
CTestDoc::CTestDoc()
CMainFrame::CMainFrame()
CMainFrame::PreCreateWindow()
CMainFrame::OnCreate()
CTestView::CTestView()
CTestView::PreCreateWindow()
CTestDoc::OnNewDocument()
Et :
CTestView::OnInitialUpdate() // Si vous la rajoutez
Le Class Wizard
Le Class Wizard, c'est l'outil Visual qui vous permet de gérer efficacement vos classes, méthodes, variables,
messages, objets...On y accède rapidement par le raccourci Ctrl+W.
1/ Class Name: désigne la classe de votre projet que vous allez mettre à jour
2/ Object IDs: désigne les ressources de votre projet, avec les noms ID_MACHIN que vous leur avez donné.
Exemple: ID_FILE_OPEN pour l'entrée du menu "File-->Open"
3/ Messages: désigne les actions en rapport avec la ressource sélectionnée. Exemple: COMMAND.
4/ Add Function: ajoute au fichier maClasse.cpp courant la fonction correspondant à l'action sélectionnée
précédemment. Exemple: OnFileOpen().
5/ Member functions: liste les méthodes ajoutées à la classe de cette manière.
6/ Member Variables: même principe, pour ajouter/enlever des variables de classe associées à vos ressources.
Sachez, pour finir, que pour ajouter vos propres méthodes ou attributs de classe, vous pouvez le faire à la main
et contrôler la disposition de votre fichier, soit le faire en "cliquant-droit" sur votre classe dans l'arborescence
sur la gauche.
Conventions de codage
Classes : Le nom d'une classe doit commencer par un 'C', puis une majuscule à chaque mot du nom.
Exemple : class CMaClasse
Fichiers : Le nom d'un fichier doit commencer par une majuscule, puis une majuscule à chaque mot du nom.
Le nom du fichier est celui de la classe qu'il contient, au 'C' près. On choisira les extensions '.h' et '.cpp'
exemple : MaClasse.h ; MaClasse.cpp
Structures : Le nom d'une structure doit commencer par un 'S', puis une majuscule à chaque mot du nom.
Exemple : struct SMaStructure
Enumération : Le nom d'une énumération doit commencer par un 'E', puis une majuscule à chaque mot du
nom.
Exemple : enum EMonEnumeration
Types : Le nom d'un type structuré ou énuméré doit être celui de la structure qu'il définit, au 'S' ou 'E' près.
Exemple : typedef struct SMaStructure MaStructure ;
Constantes : Le nom d'une constante doit être fait de majuscules, les mots du nom étant séparés par des '_'.
Exemple : const int TAILLE_TABLO = 256 ;
Il existe 3 types de constantes en C++ :
Les constantes globales et visibles n'importe où, déclarées dans un .h et définies dans le .cpp correspondant :
extern int TAILLE_TABLO ; // dans le .h
extern int TAILLE_TABLO = 256 ; // dans le .cpp
Les constantes de classe, déclarées statiques comme attributs de classe :
static const int TAILLE_TABLO = 256 ;
Les constantes globales visibles dans le .cpp où elles sont définies :
static static const int TAILLE_TABLO = 256 ; // dans le .cpp
Variables : Le nom d'une variable doit commencer par une majuscule, puis une majuscule à chaque mot du
nom. On ajoute des préfixes aux variables : le premier indique la portée de la variable, le second, le type de la
variable.
Exemple : public : int m_nTailleTablo ;
Portée
m_
l_
p_
g_
Membre de classe
Variable locale
Paramètre
Variable globale
Type
p
g
n
l
sz
f
d
c
b
pointeur
Objet graphique
int
long
String, char*
float
double
char
bool
Ressources : Le nom d'une ressource doit être fait de majuscules, les mots du nom étant séparés par des '_'. On
rajoute un préfixe au nom, suivant le type de la ressource.
Exemple : IDB_FOND_D_ECRAN
Type
IDB_
IDS_
IDD_
IDI_
IDC_
IDR_
ID_
Bitmap
String
Dialog
Icon
Control
Autre ressource
Commande
Commentaires : Il existe deux types de commentaires :
// Commentaire utile a la compréhension du programme, ex :
// Tant que le buffer n'est pas vide
while (!buffer.IsEmpty())
Documentation
/*
* Code mort, code en attente, code beta, ...
*/
Il faut bien distinguer les commentaires de la documentation. Cette dernière est faite de commentaires spéciaux
lisibles par des programmes comme javadoc ou doxygen.
Ces commentaires sont encore de deux types :
//! Description d'un attribut ou d'un champ de structure, d'énumération
/*!
* Description de fichier, de classe, de méthode
* @author
* @version 01/15/2002
* @param p_MonParam description d'un paramètre
* @return Description de la valeur renvoyée
*/
Inclusions : Ici aussi on cherchera à être propre, à ne pas en mettre partout, donc règle : les inclusions de
modules perso se font dans le header, l'inclusion trouvée dans le .cpp est celle du .h correspondant.
Raccourcis clavier
Raccourci
Commande
F1
Ouvrir l'aide MSDN pour le mot en surbrillance.
Ctrl+F2
Enregistrer la position courante.
F2
Aller à la prochaine position enregistrée.
Ctrl+F3
Chercher l'expression en surbrillance.
F3
Aller au suivant.
F4
Aller à la prochaine erreur de compilation.
Ctrl+F5
Exécuter le programme.
F5
Débugger le programme / avancer jusqu'au prochain point d'arrêt.
Shift+F5
Arrêter le débuggage.
F7
Construire le projet.
Ctrl+F7
Compile le fichier courant.
Ctrl+F8
Activer la surbrillance.
F9
Ajouter/Enlever un point d'arrêt.
F10
Avancer d'un pas dans le débuggage.
Ctrl+F10
Aller jusqu'au curseur dans le débuggage.
F11
Entrer dans la fonction, dans le débuggage.
Shift+F11
Sortir de la fonction, dans le débuggage.
F12
Browse project.
Ctrl+G
Goto Line.
Ctrl+W
Launch wizard.
Ctrl+Space
Complete word.
Ctrl+L
Delete previous line.
Ctrl+J
Atteindre le précédent #if.
Ctrl+K
Atteindre le #endif suivant.
Ctrl+H
Replace.
Ctrl+F
Find.
Ctrl+X/C/V
Cut/Copy/Paste.
Ctrl+Z/Y
Undo/Redo.

Programmation Windows : environnement

Transcription

Documents pareils

Multifunctional Converter for Solar Water Pump

bulletin adhésion mars 2013 - Mutuelle Familiale de la Corse

Mon CV - Site Web de Wizou

CV au format PDF

recrute - Neuilly

Pour se rendre au Comité - (CPP) Sud

FDP Saitek X52 Flight Control System

Set of panel legs LB051 is required for the sides of reception desk

JOB VACANCY - monaco technologies