[FAQ VC++]Comment exploiter efficacement l'exportation des classes C++
Dans l'environnement de VS et en particulier des MFC avec Visual C++, nous avons deux types de dlls pour ce qui concerne l'exportation d'objets.
1. Si vous envisager d'exporter que des fonctions alors les Dlls régulière MFC sont pour vous.
2. Si vous envisager d'exporter des classes C++ alors dans ce cas et uniquement dans ce cas les Dlls d'extension MFC sont pour vous. N'empêche que l'on peut aussi étendre à l'exportation des fonctions avec ce genre de dlls.
La façon la plus simple et la plus rapide de créer une dll d'extension MFC est de vous laisser assister par les assistants de création de projet qui va correctement configurer pour vous les paramètres de vos dlls d'extension.
Ici je vais procéder par l'exemple pour vous montrer comment exploiter efficacement l'exportation des classes C++ MFC sous deux volets l'un au niveau du code source et l'autre au niveau des paramétrages des projets.
Soit une solution contenant 4 projets dont 2 dlls et 2 exe. Les projets de dlls sont essentiellement des dlls d'extension MFC contenant des classes de bases réutilisables pour une application MFC (exe) tierce.
dans une dll d'extension MyBase.dll qui fournit des fonctionnalités de base on a :
Code:
1
2
3
4
5
6
7
|
class AFX_EXT_CLASS CMyBaseWinApp : public CWinAppEx { ... };
class AFX_EXT_CLASS CMyBaseMainFrame : public CMDIFrameWndEx { ... };
class AFX_EXT_CLASS CMyBaseDocument : public CDocument { ... };
class AFX_EXT_CLASS CMyBaseTreeView : public CTreeView { ... };
class AFX_EXT_CLASS CMyBaseDockablePane : public CDockablePane { ... };
class AFX_EXT_CLASS CMyPersonnalMfcClass : public CObject { ... }; |
dans une autre dll d'extension MyExtend.dll qui fournit des fonctionnalités étendues ou enrichies on a :
Code:
1
2
3
4
5
6
7
|
class AFX_EXT_CLASS CMyRichWinApp : public CMyBaseWinApp { ... };
class AFX_EXT_CLASS CMyRichMainFrame : public CMyBaseMainFrame { ... };
class AFX_EXT_CLASS CMyRichDocument : public CMyBaseDocument { ... };
class AFX_EXT_CLASS CMyRichTreeView : public CMyBaseTreeView { ... };
class AFX_EXT_CLASS CMyRichDockablePane : public CMyBaseDockablePane { ... };
class AFX_EXT_CLASS CMyRichPersonnalMfcClass : public CMyPersonnalMfcClass { ... }; |
cette dll exploite la dll MyBase.dll
Vous remarquerez que la macro AFX_EXT_CLASS utilisée dans les dlls instruit au compilateur de VC++ que la classe est exportable.
dans une application MFC MySimpleApp.exe exploitant les fonctionnalités de base on a :
Code:
1
2
3
4
5
6
7
|
class CSimpleWinApp : public CMyBaseWinApp { ... };
class CSimpleMainFrame : public CMyBaseMainFrame { ... };
class CSimpleDocument : public CMyBaseDocument { ... };
class CSimpleTreeView : public CMyBaseTreeView { ... };
class CSimpleDockablePane : public CMyBaseDockablePane { ... };
class CSimplePersonnalMfcClass : public CMyPersonnalMfcClass { ... }; |
dans une autre application MFC MyPowerApp.exe exploitant les fonctionnalités étendues ou enrichie on a:
Code:
1
2
3
4
5
6
7
|
class CPowerWinApp : public CMyRichWinApp { ... };
class CPowerMainFrame : public CMyRichMainFrame { ... };
class CPowerDocument : public CMyRichDocument { ... };
class CPowerTreeView : public CMyRichTreeView { ... };
class CPowerDockablePane : public CMyRichDockablePane { ... };
class CPowerPersonnalMfcClass : public CMyPersonnalMfcClass { ... }; |
Voici les principes d'utilisation efficaces des dlls sans se perdre avec les *.h ou les lib ou les problèmes de référencement entre projets. D'ailleurs on pouvais même ajouter des dll .NET comme des projets dans la même solution et qui soit exploitable par ces 4 projets natives mais qui deviendraient mixte dans ce cas. Mais restons en là d'abord au monde du natif.
1. Project Dependencies
Il faut régler le problème de dépendances des projets au sein d'une même solution. En cliquant droit sur un des projets vous sélectionnez rapidement la commande de dépendances des projets. MyBase.dll vient en premier, MyExtend.dll vient en second ensuite les exe MySimpleApp.exe en troisième et MyPowerApp.exe en quatrième. Ainsi lors de la compilation de la solution (je n'ai pas dis du projet) les projets qui la composent sont compilés dans le bon ordre. Vous pouvez vérifier l'ordre de compilation dans la commande Build Order du même menu contextuel sur un projet.
2. Les includes
Puisque les dlls sont aux services des exe. Il est préférable de ranger la définition de chacune de vos classes exportables dans des fichiers séparés.
Par exemple dans MyBase.dll on a :
CMyBaseWinApp dans son MyBaseWinApp.h
CMyBaseMainFrame dans son MyBaseMainFrame.h
CMyBaseDocument dans son MyBaseDocument.h
etc...
Et ensuite réunir l'ensemble de ces includes dans un seul fichier MyBase.h comme
Code:
1
2
3
4
5
6
7
8
9
10
11
|
// MyBase.h
#pragma once
#include "Je peux inclure ici d'autres fichiers en tête afin de résourdre des problèmes de référencement à mes classes d'exportation"
#include "MyBaseWinApp.h"
#include "MyBaseMainFrame.h"
#include "MyBaseDocument.h"
etc |
Idem pour la dll MyExtend.dll
Au final pour ce qui est des includes nous n'avons que 2 fichiers MyBase.h et MyExtend.h. Et donc il est inutile de se perde avec l'ensemble des fichiers en-têtes que peuvent composer vos dlls. Rassurer qu'un seul fichier en-tête d'exportation soit produite par dll.
3. Paramétrages des output des projets
Ici il est maintenant question de paramétrer les sorties des projets de votre solution.
Vous devez vérifier ou configurer vos projets de manière à ce que leurs output soient produits aux mêmes endroits. Afin d'éviter à un projet de réclamer un output dont il dépend (par exemple une librairie qu'il ne voit pas)
Dans les options de chaque projet il faut définit un output directory commun généralement General > Output Directory : votre répertoire commun (en debug et en release)
Toujours dans les options Linker > Advanced > Import Library : le path de vos lib (en debug et en release)
4. Référencer les includes
Puisque MyExtend.dll dépend de MyBase.dll il faut inclure son unique fichier MyBase.h dans le stdAfx.h du projet MyExtend.dll
Code:
1
2
3
4
5
6
|
// stdAfx.h de MyExtend.dll
...
#include "..\Mybase\MyBase.h" |
Code:
1
2
3
4
5
6
|
// stdAfx.h de MySimpleApp.exe
...
#include "..\Mybase\MyBase.h" |
Code:
1
2
3
4
5
6
|
// stdAfx.h de MyPowerApp.exe
...
#include "..\Mybase\MyBase.h"
#include "..\MyExtend\MyExtend.h" |
En effet le stdAfx.h est le meilleur endroit ou les risque de modification sont peu probablement.
5. Référencer les librairies
Nous savons que les 4 projets sont dépendants dans l'ordre suivant
MyBase.dll > MyExtend.dll > MySimpleApp.exe > MyPowerApp.exe
pour MyExtend.dll
Linker > Input > Additional Dependencies : MyBase.lib
pour MySimpleApp.exe
Linker > Input > Additional Dependencies : MyBase.lib;
pour MyPowerApp.exe
Linker > Input > Additional Dependencies : MyBase.lib;MyExtend.lib
Bon je crois que je n'ai rien oublié. Compilez la solution, définissez le projet de démarrage et lancer l'exécution de votre Power MFC Application!!!
:D
