Gestion de modules
Le
Piezo
Bonjour,
Je tente de faire un programme en c++ extensible par des modules
(compilés et "linkés" avec l'exécutable). Chacun de ces modules est une
classe, héritée d'une même classe mère (pour un typage commun entre
eux). Le programme, à son lancement, instancie toutes les
classes-modules et enregistre leur pointeur dans un tableau pour une
utilisation future.
Le problème est que j'aurai une bonne vingtaine de modules, et que
rajouter manuellement toutes les includes et les "new" dans mon main
pour construire ma bibliothèque de modules (tableau d'objets) sera
laborieux. Je cherche donc une solution pour automatiser cette tache.
Make me semble tout indiqué pour automatiser l'édition de lien,
mais je ne vois vraiment pas comment automatiser l'instanciation de mes
modules.
pour l'instant j'ai :
//Je veux automatiser ceci :
#include "ModuleA.h"
#include "ModuleB.h"
#include "ModuleB.h"
//Classe mère
class CModules{
//Déclarations
};
//Exemple de module: (dans ModuleA.h):
class ModuleA:public CModules{
public:
//Surcharge des méthodes "virtual" de CModules
private:
//Déclarations
};
//Méthode de création de ma bibliothèque:
CModules** CreateModules(){
//Mon tableau de pointeur de modules
CModules** Modules = new CModules*[/* Trouver le nombre de modules*/];
//ainsi que l'instanciation :
Modules[0] = new ModuleA;
Modules[1] = new ModuleB;
Modules[2] = new ModuleC; //etc
Modules[3] =
return Modules;
}
Piezo
Je tente de faire un programme en c++ extensible par des modules
(compilés et "linkés" avec l'exécutable). Chacun de ces modules est une
classe, héritée d'une même classe mère (pour un typage commun entre
eux). Le programme, à son lancement, instancie toutes les
classes-modules et enregistre leur pointeur dans un tableau pour une
utilisation future.
Le problème est que j'aurai une bonne vingtaine de modules, et que
rajouter manuellement toutes les includes et les "new" dans mon main
pour construire ma bibliothèque de modules (tableau d'objets) sera
laborieux. Je cherche donc une solution pour automatiser cette tache.
Make me semble tout indiqué pour automatiser l'édition de lien,
mais je ne vois vraiment pas comment automatiser l'instanciation de mes
modules.
pour l'instant j'ai :
//Je veux automatiser ceci :
#include "ModuleA.h"
#include "ModuleB.h"
#include "ModuleB.h"
//Classe mère
class CModules{
//Déclarations
};
//Exemple de module: (dans ModuleA.h):
class ModuleA:public CModules{
public:
//Surcharge des méthodes "virtual" de CModules
private:
//Déclarations
};
//Méthode de création de ma bibliothèque:
CModules** CreateModules(){
//Mon tableau de pointeur de modules
CModules** Modules = new CModules*[/* Trouver le nombre de modules*/];
//ainsi que l'instanciation :
Modules[0] = new ModuleA;
Modules[1] = new ModuleB;
Modules[2] = new ModuleC; //etc
Modules[3] =
return Modules;
}
Piezo
Poser une question
Pour faire un système facilement extensible, le plus simple est de faire du
link dynamique ( ce qui correspond à créer des plugins)
Dans les grandes lignes, le principe est le suivant:
Pour créer des plugins, il faut créer une dll ( regulière) qui contient le
code et un jeu de fonctions prédéfinies.
Ensuite dans son programme , on recherche par exemple les dlls dans un
répertoire donné (fonction filefind ...) puis on les charge avec la fonction
loadlibrary.
Une fois la dll chargée il faut faire des getprocadress pour avoir des
pointeur sur des fonctions définies dans la dll.
Le plus simple est de gérer une liste de classe wrapper ( classe qui
encapsule les appels d'une dll donnée).
Dans ton cas, on peut aussi créer des fonctions pCreateXXX qui rendent des
pointeurs vers les nouvelles classes créees. ....
"Piezo" news:43b54e48$0$21041$
J'aurais préféré compiler mes module en "dur" et les "linkés" avec
l'exécutable final.
Je vais me débrouiller autrement.
Une petite question ici : est-ce que chacune de ces modules est
un objet unique, comme il en a l'air ? Si oui, pour assurer
l'instanciation de l'objet, il suffit d'en définir l'instance à
une portée d'espace référentiel (éventuellement, par exemple,
dans un namespace anonyme) ET de s'assurer que le fichier object
qui en contient l'instance fasse partie de ton programme.
(Attention au deuxième point : le fait que l'objet se trouve
dans une bibliothèque que tu spécifies ne suffit pas. Il faut
bien donner le nom du fichier objet même à l'éditeur de liens.)
Ensuite, pour que l'objet se trouve dans un tableau, la solution
classique est d'utiliser un singleton std::set< Module* > ou
std::map< KeyType, Module* >, et que le constructeur de CModules
s'y inscrit l'objet, par exemple (avec std::set) :
CModules::CModules()
{
Modules::instance().insert( this ) ;
}
Ici, on se sert du modèle classique de singleton en C++ pour
résoudre les problèmes de l'ordre d'initialisation.
--
James Kanze mailto:
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 pl. Pierre Sémard, 78210 St.-Cyr-l'École, France +33 (0)1 30 23 00 34
Tout à fait. Le chargement dynamique introduit des possibilités
supplémentaires d'erreur (problèmes d'incompatibilité des
versions, etc.), et complique la diffusion du programme.
--
James Kanze mailto:
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 pl. Pierre Sémard, 78210 St.-Cyr-l'École, France +33 (0)1 30 23 00 34