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.
//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] = ...
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
patrick
Bonjour,
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" a écrit dans le message de news:43b54e48$0$21041$
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.
//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
Bonjour,
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" <contact@smblog.tk> a écrit dans le message de
news:43b54e48$0$21041$636a55ce@news.free.fr...
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.
//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] = ...
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" a écrit dans le message de news:43b54e48$0$21041$
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.
//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
Piezo
Merci pour la réponse.
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.
Bonjour,
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. ....
Merci pour la réponse.
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.
Bonjour,
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. ....
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.
Bonjour,
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. ....
James Kanze
Piezo wrote:
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.
//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; }
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
Piezo wrote:
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.
//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;
}
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: james.kanze@free.fr
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
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.
//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; }
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
James Kanze
Piezo wrote:
J'aurais préféré compiler mes module en "dur" et les "linkés" avec l'exécutable final.
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
Piezo wrote:
J'aurais préféré compiler mes module en "dur" et les "linkés"
avec l'exécutable final.
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: james.kanze@free.fr
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
J'aurais préféré compiler mes module en "dur" et les "linkés" avec l'exécutable final.
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
