Méthode de chargement dynamique de fonctions

Version imprimable

Bonjour tout le monde!
Je vous explique rapidement le but de ce sujet: je dois produire une bibliothèque statique qui contient une classe abstraite A et plusieurs classes filles (B, C, D). Chacune de ces classes filles dépendent de bibliothèques différentes les unes des autres (BLib, CLib, DLib).
Le problème est le suivant: chez certains utilisateurs, les bibliothèques des classes filles ne seront pas disponibles donc il ne pourront pas compiler ma bibliothèque. Pour parer ce problème j'ai utilisé des instructions préprocesseur pour indiquer si une bibliothèque fille est présente ou non:
Code:

1 2 3 4 5 6 7 8 9 #if _BLIB_FOUND #include "blib.h" class B : public A { ... }; #endif
Avec cette méthode, la bibliothèque peut compiler sans problème. Seulement voilà, maintenant, il faudrait que j'ai une fabrique à laquelle je passe en paramètre le nom de la classe fille et qui m'instancie la classe correspondante.

Ma première approche fut de faire un "vulgaire" switch de la manière suivante:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 void buildClass(int className, A* returnClass) { switch (className) { case 0: returnClass = new B(); break; case 1: returnClass = new C(); break; case 2: returnClass = new D(); break; default: cerr << "Class not defined" << endl; } }
Seulement voilà... ca ne compilera seulement si l'utilisateur possède toutes les bibliothèques dépendantes...

Voici ma nouvelle idée: charger les méthodes (à savoir ici les constructeurs de classes) de manière dynamique.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 void buildClass(std::string className, A* returnClass) { //Permet de charger une méthode qui construit un objet. void* classMetod = loadClass(className); if(!returnClass) { cerr << "Class not defined" << endl; } else { //Cree l'objet de type className. classMethod(returnClass); } }
Mon problème c'est comment instancié cette méthode (loadClass). Est-ce possible?
Je sais que ce genre de fonction existe notamment en openGL avec la méthode glxGetProcAdress mais je ne trouve pas son implémentation.

Si vous avez une idée, je suis tout à fait preneur!

Merci d'avance.

19/10/2011, 12h55
Steph_ng8

Bonjour.
L'un des deux tutoriels suivants pourra peut-être répondre (au moins partiellement) à tes questions...
Appels de méthodes déterminés dynamiquement
Exportation de classes C++ dans une bibliothèque dynamique sous Linux

Bon courage.
19/10/2011, 15h05
darkman19320

Merci Stef pour ta réponse.
Pour la partie chargement dynamique de méthode à partir d'une bibliothèque dynamique, je ne pense pas que ce soit approprié pour mon problème. Je n'ai que des classes statiques. De plus je pense que le chargement dynamique ne se fait pas de la même façon sur un système type Unix que sous Windows. Or ma bibliothèque doit être multi-plateformes.

Pour le premier lien je vais regarder ça plus en détail.
19/10/2011, 15h32
jblecanard
Hello

Pourquoi vouloir passer le nom en paramètre ? L'utilisateur ne peut il pas simplement appeler des méthodes CreerClassB(), CreerClassC() et CreerClassD() ?

Quelle que soit la réponse à cette question, deux solutions possibles :
- Utiliser tes flags _XLIB_FOUND dans l'implémentation pour faire un = null au lieu d'un new pour les libs non disponibles.
- La solution préconisée : configurer ton outil de compilation pour qu'il utilise des *.cpp différents en fonction de la disponibilité ou non des libs. Rien ne t'empêche de mettre CreerClassB, CreerClassC et CreerClassD dans des *.cpp différents, quand bien même ils seraient déclarés dans la même factory.

Puisque l'utilisateur dispose du code source, l'usage de la spécialisation template peut également répondre à ton problème de manière simple :
Code:

1 2 3 4 5 6 7 8 9 10 11 template < typename T > struct Factory { T* CreerClass(); }; #if _BLIB_FOUND template <> B* Factory<B>::CreerClasse() { return new B(); }; #endif
Code:

1 2 // Code utilisateur A* pMaClass = Factory<B>::CreerClasse();
PS : Dans ton code, la signature que tu proposes devrait être

Code:

void buildClass(int className, A*& returnClass);

avec une référence sur le pointeur sinon, ça marche pô ;).
20/10/2011, 09h03
darkman19320

Bonjour,
Merci pour ta réponse!
C'est vrai que la proposition que tu proposes est relativement simple.

Par contre, je pense qu'il faut tout de même rajouter les flags #if _XLIB_FOUND au niveau du code utilisateur non?

Citation:

Pourquoi vouloir passer le nom en paramètre ? L'utilisateur ne peut il pas simplement appeler des méthodes CreerClassB(), CreerClassC() et CreerClassD() ?

Je souhaiterais juste que l'utilisateur n'est pas accès à ces méthodes, il ferait appel à

Code:

void buildClass(int className, A*& returnClass);

où className serait récupérer à partir d'un fichier de conf ce qui permetrer d'éviter de re-compiler à chaque fois si l'on souhaite utiliser tel ou tel classe fille.
Je fais mon prototype et je vous tiens au courant de la solution que j'aurai choisie.
20/10/2011, 09h48
jblecanard

Citation:

Envoyé par darkman19320

Par contre, je pense qu'il faut tout de même rajouter les flags #if _XLIB_FOUND au niveau du code utilisateur non?

Non. Si tu configures ta chaîne de compilation pour choisir les *.cpp adéquats, tu n'en auras pas besoin dans le code. Il suffit de goupiller son implémentation pour que la requête sur une classe non disponible renvoie un pointeur nul.
20/10/2011, 11h30
darkman19320

Tu es sûr parce que si tu défini ce code

Code:

A* pMaClass = Factory<B>::CreerClasse();

Et que B n'est pas définie, il y aura forcément une erreur de compilation.
20/10/2011, 11h31
jblecanard

Citation:

Envoyé par darkman19320

Tu es sûr parce que si tu défini ce code

Code:

A* pMaClass = Factory<B>::CreerClasse();

Et que B n'est pas définie, il y aura forcément une erreur de compilation.

Oui car là tu parles de l'autre solution, celle avec les templates.

Je vais te filer un exemple plus parlant pour celle que je te propose.

Voici un exemple complet, avec CMake comme chaîne de compilation :

CMakeLists.txt

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
project(Factory)
 
include_directories(${PROJECT_SOURCE_DIR})
set(SOURCE_FILES ${PROJECT_SOURCE_DIR}/main.cpp ${PROJECT_SOURCE_DIR}/Factory.cpp)
 
# A voir chez toi comment générer les bons flags
set(LIBB_FOUND "LibB-Found")
set(LIBC_FOUND "LibC-NotFound")
 
if(LIBB_FOUND)
    set(SOURCE_FILES "${SOURCE_FILES}" ${PROJECT_SOURCE_DIR}/FactoryImpl/FactoryLibBFound.cpp)
else()
    set(SOURCE_FILES "${SOURCE_FILES}" ${PROJECT_SOURCE_DIR}/FactoryImpl/FactoryLibBMissing.cpp)
endif(LIBB_FOUND)
 
if(LIBC_FOUND)
    set(SOURCE_FILES "${SOURCE_FILES}" ${PROJECT_SOURCE_DIR}/FactoryImpl/FactoryLibCFound.cpp)
else()
    set(SOURCE_FILES "${SOURCE_FILES}" ${PROJECT_SOURCE_DIR}/FactoryImpl/FactoryLibCMissing.cpp)
endif(LIBC_FOUND)
 
add_executable(test ${SOURCE_FILES})

A.h

Code:

1
2
3
4
5
6
7
8
#ifndef A_H
#define A_H
 
class A
{
};
 
#endif

B.h

Code:

1
2
3
4
5
6
7
#ifndef B_H
#define B_H
 
class B : public A
{};
 
#endif

C.h

Code:

1
2
3
4
5
6
7
#ifndef C_H
#define C_H
 
class C : public A
{};
 
#endif

Factory.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#ifndef Factory_H
#define Factory_H
 
class A;
 
class Factory
{
    A* CreerClasseB();
    A* CreerClasseC();
 
public:
    enum ClassName{ LibB, LibC};
    A* CreateClass(ClassName iClassToCreate);
};
 
#endif

main.cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <iostream>
#include "Factory.h"
#include "A.h"
 
int main(int argc, char * argv[])
{
    Factory myFact;
    A* pObjectB = myFact.CreateClass(Factory::LibB);
    A* pObjectC = myFact.CreateClass(Factory::LibC);
    if(pObjectB)
    {
        std::cout << "Usage of lib B Ok !" << std::endl;
        delete pObjectB;
    }
 
    if(pObjectC)
    {
        std::cout << "Usage of lib C Ok !" << std::endl;
        delete pObjectC;
    }
 
    return 0;
}

Facory.cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include "Factory.h"
#include "A.h"
 
A* Factory::CreateClass(ClassName iClassToCreate)
{
    A* pObject = 0;
    switch(iClassToCreate)
    {
    case LibB:
        pObject = CreerClasseB();
        break;
    case LibC:
        pObject = CreerClasseC();
        break;
    default:;
    }
 
    return pObject;
}

FactoryImpl/FactoryLibBFound.cpp

Code:

1
2
3
4
5
6
7
8
#include "Factory.h"
#include "A.h"
#include "B.h"
 
A* Factory::CreerClasseB()
{
    return new B();
}

FactoryImpl/FactoryLibBMissing.cpp

Code:

1
2
3
4
5
6
7
#include "Factory.h"
#include "A.h"
 
A* Factory::CreerClasseB()
{
    return 0;
}

FactoryImpl/FactoryLibCFound.cpp

Code:

1
2
3
4
5
6
7
8
#include "Factory.h"
#include "A.h"
#include "C.h"
 
A* Factory::CreerClasseC()
{
    return new C();
}

FactoryImpl/FactoryLibCMissing.cpp

Code:

1
2
3
4
5
6
7
#include "Factory.h"
#include "A.h"
 
A* Factory::CreerClasseC()
{
    return 0;
}

De cette manière, d'une part tout est résolu à la compilation, et d'autre part, si le code de création se complexifie, tu n'auras pas à te pourrir la vue avec des flags préprocesseurs dans tous les sens.

Par contre ça demande de maîtriser sa chaîne de compilation.

20/10/2011, 18h51
darkman19320

Merci encore pour ta contribution!!
Je comprends tout à fait l’intérêt et la facilité d'utiliser ta méthode.
Par contre il serait peut être plus préférable d'avoir un seul fichier FactoryLibMissing.cpp contenant toutes les méthodes qui retournent des pointeurs NULL.

Je vais tester tout ça, en parler à mes collègues et je vous tiens au courant!

Merci encore pour tout.
21/10/2011, 10h50
jblecanard

Citation:

Envoyé par darkman19320

Par contre il serait peut être plus préférable d'avoir un seul fichier FactoryLibMissing.cpp contenant toutes les méthodes qui retournent des pointeurs NULL.

Ben non, car il ne fonctionnerait que si aucune lib n'est disponible. Après il y a peut être moyen de faire plus malin avec moins de fichiers, mais faut voir avec vos use cases en effet.
22/10/2011, 10h19
3DArchi

Salut,

Il me semble que POCO t'évitera de réinventer la roue ;)
24/10/2011, 16h05
darkman19320

Bonjour tout le monde!

Pour vous tenir au courant, nous avons décider d'utiliser la méthode avec les template et non pas avec la méthode par choix de fichier pour plusieurs raisons dont éviter d'avoir trop de fichiers (pas un vrai argument pour ma part...), et surtout, si par le plus grand des hasards et de mal chance, CMake deviendrait payant où du moins que ces sources ne soient plus disponible librement (fortement improbable).

Je vous remercie à tous pour votre soutien.

PS: @3DArchi merci pour le lien!! Il me servira certainement pour un autre projet, nous n'utilisons que des bibliothèques statiques dans notre cas.