Opzioni plug-in boost

Question

Sto cercando di implementare un'architettura plug-in nella nostra attuale applicazione (Unix, C++) e ho esaminato le opzioni (in attesa di approvazione) all'interno delle librerie Boost.

Modifica: sto cercando di aggiungere in modo dinamico le classi in fase di esecuzione.

Boost.Plugin

Boost.Reflection

Boost.Extension

Mi chiedevo che cosa tutti quanti esperienza/opinione su queste e altre implementazioni.

Answer 1

Eh. Abbiamo appena utilizzato dlopen e dlsym insieme con un paio di extern "C" static funzioni che deve essere definito nella DLL

extern "C" static plugin* create(arg_pack*); 
extern "C" static errno_t destroy(plugin*); 

Dai un'occhiata plug-manager per i file ".so" ".dll" o e caricarli in un
map<string, pair< plugin*(*)(arg_pack*), errno_t(*)(plugin*)> >

è quindi possibile occhiata un plugin in base al nome (la stringa sopra) e ottenere è 'costruttore' o 'distruttore'

vedi anche: gmodule

Answer 2

Non è possibile caricare le classi in fase di esecuzione poiché il C++ è un linguaggio compilato e le classi non esistono in fase di esecuzione. Oggetti (istanze di classi).

Quello che puoi fare è caricare le librerie condivise in fase di esecuzione e farle creare oggetti di una determinata interfaccia.

L'implementazione di plug-in minima definisce l'interfaccia del plug-in e l'interfaccia della funzione di fabbrica che sta per creare oggetti con tale interfaccia. Caricherai la libreria condivisa in fase di esecuzione, troverai la funzione di fabbrica con un certo nome e chiami la funzione di fabbrica per creare un oggetto. Quindi si utilizza quell'oggetto attraverso l'interfaccia:

// plugin.h start 
#include <memory> 

struct PlugIn // interface 
{ 
    virtual ~PlugIn() = 0; 
    virtual void doSomething() = 0; 
}; 

extern "C" { 

typedef std::auto_ptr<PlugIn> PlugInFactoryFn(); 

// A plugin .so must export this one factory function. 
std::auto_ptr<PlugIn> createPlugIn(); 

} 
// plugin.h end 

// somewhere in you application 
#include "plugin.h" 
#include <assert.h> 
#include <dlfcn.h> 

std::auto_ptr<PlugIn> loadPlugIn(char const* filename) 
{ 
    void* so = dlopen(filename, RTLD_NOW | RTLD_LOCAL); 
    assert(so); 
    void* factory_function = dlsym(so, "createPlugIn"); 
    assert(factory_function); 
    return reinterpret_cast<PlugInFactoryFn*>(factory_function)(); 
} 

int main() 
{ 
    std::auto_ptr<PlugIn> a(loadPlugIn("a.so")); 
    std::auto_ptr<PlugIn> b(loadPlugIn("b.so")); 
    a->doSomething(); 
    b->doSomething(); 
}