C++: le chargement dynamique de classes à partir de dll

Meilleure façon de le faire, à mon humble avis, est d'avoir un simple C une fonction qui retourne un pointeur vers une interface décrit par ailleurs. Alors votre application, pouvez appeler toutes les fonctions de cette interface, sans vraiment savoir dans quelle classe il est à l'aide.

Edit: Voici un exemple simple.

Dans le code de l'application, vous créez un en-tête de l'interface:

class IModule
{
public:
    virtual ~IModule(); //<= important!
    virtual void doStuff() = 0;
};

Principal de l'application est codée pour utiliser l'interface ci-dessus, sans plus de détails sur la mise en œuvre effective de l'interface.

class ActualModule: public IModule
{
/* implementation */
};

Maintenant, les modules de la DLL effectivement implémentations de cette interface, et les classes n'ont même pas à être exportés - __declspec (dllexport) n'est pas nécessaire. La seule exigence pour les modules est d'exporter une fonction unique, qui permettrait de créer et de retourner une implémentation de l'interface:

__declspec (dllexport) IModule* CreateModule()
{
    //call the constructor of the actual implementation
    IModule * module = new ActualModule();
    //return the created function
    return module;
}

remarque: la vérification des erreurs laissées vous feriez habituellement à vérifier, si de nouveaux renvoyé le bon pointeur et vous devriez vous protéger contre les exceptions qui peuvent être jetés dans le constructeur de la ActualModule classe.

Puis, dans votre application, tout ce que vous devez faire est simplement de charger le module (LoadLibrary fonction) et de trouver la fonction CreateModule (GetProcAddr fonction). Ensuite, vous utilisez la classe par le biais de l'interface.

Edit 2: votre RefCount (classe de base de l'interface), peuvent être mises en œuvre (et exportés à partir de) l'application principale. Alors tous vos module aurait besoin d'un lien vers le fichier lib de l'application principale (oui! Les fichiers EXE peuvent avoir LIB fichiers comme les fichiers DLL!) Et cela devrait être suffisant.

[Edit: pendant que j'était en train de composer tout cela, Paulius Maruška édité son commentaire à-dire essentiellement la même. Alors, toutes mes excuses pour le double emploi. Mais je suppose que vous avez maintenant en ai un de rechange :)]

Sur le dessus de ma tête, et en supposant que Visual C++...

Vous devez utiliser la fonction LoadLibrary de charger une DLL dans dynamiquement, puis utilisez GetProcAddress pour rechercher l'adresse d'une fonction qui va créer la classe dérivée que le code de la DLL met en œuvre. Comment vous décidez de faire cette précision est à vous (les Dll doivent trouver, à la manière de l'exposer leurs besoins en fonctionnalités de la spécification, etc.) donc pour l'instant, supposons que les plugins ne fournit de nouvelles Sprite implémentations.

Pour ce faire, décider sur la signature de la fonction dans la DLL que le programme principal appelle à créer un de ces nouveaux sprites. Celui-ci semble adapté:

typedef Sprite *(*CreateSpriteFn)();

Puis, à partir du programme principal, vous aurez à charger une DLL (encore une fois, comment vous trouver cette DLL est jusqu'à vous) et obtenir le sprite de la création de la fonction d'elle. J'ai décidé que le sprite de la création de la fonction sera appelée "CreateSprite":

HMODULE hDLL=LoadLibrary(pDLLName);
CreateSpriteFn pfnCreateSprite=CreateSpriteFn(GetProcAddress(hDLL,"CreateSprite"));

Ensuite pour créer l'un de ces, il suffit d'appeler la fonction:

Sprite *pSprite=(*pfnCreateSprite)();

Une fois que vous avez terminé avec la DLL et il n'existe pas de gauche objets qui ont été créés par elle, vous pouvez alors l'utiliser FreeLibrary pour se débarrasser d'elle:

FreeLibrary(hDLL);

Pour créer une DLL que le sport cette interface, d'écrire le code de la classe dérivée et ainsi de suite, alors quelque part dans le code de la DLL fournir les CreateSprite fonction que le programme appelant besoins, à l'aide de la signature:

__declspec(dllexport)
extern "C"
Sprite *CreateSprite()
{
    return new MyNewSprite;
}

La dllexport chose signifie que vous pouvez utiliser GetProcAddress pour prendre cette fonction par le nom, et la extern "C" permet de s'assurer que le nom est unmangled et ne finissent pas comme "CreateSprite@4" ou quelque chose du genre.

Deux autres notes:

1. GetProcAddress renvoie 0 si il ne trouve pas la fonction, de sorte que vous pouvez l'utiliser pour parcourir une liste de Dll (p. ex., retour de FindFirstFile et amis) à la recherche pour les Dll de l'interface, et/ou essayer de trouver de multiples points d'entrée et prendre en charge plusieurs types par plugin.
2. si le programme principal va supprimer le sprite à l'aide de l'opérateur d'effacement, cela nécessite que les deux DLL et le programme principal sont construits à l'aide de la même bibliothèque d'exécution, de sorte que le programme principal est de supprimer et de le DLL nouvelles sont à la fois en utilisant le même tas. Vous pouvez contourner ce dans une certaine mesure par le fait d'avoir la DLL fournir un DeleteSprite fonction, qui supprime le sprite à l'aide de la DLL de la bibliothèque d'exécution plutôt que le programme principal, mais vous avez encore de prendre soin de tout le reste de votre programme, de sorte que vous pouvez juste vouloir forcer DLL écrivains à les utiliser de la même bibliothèque d'exécution de votre programme. (Je ne dirais pas que tu serais en bonne compagnie en faisant cela, mais il n'est pas rare. 3D Studio MAX exige, par exemple).