Opción Boost Plugin

Question

Estoy buscando implementar una arquitectura de complemento en nuestra aplicación actual (Unix, C++) y he estado revisando las opciones (pendiente de aprobación) dentro de las bibliotecas de Boost.

Editar: Estoy buscando agregar dinámicamente clases en tiempo de ejecución.

Boost.Plugin

Boost.Reflection

Boost.Extension

Me preguntaba qué gustos de la experiencia/opinión está en estas y otras implementaciones.

Answer 1

Eh. Sólo se utiliza dlopen y dlsym junto con un par de extern "C" static funciones que debe definirse en el archivo DLL

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

un vistazo plugin-gestor de archivos ".so" ".dll" o y cargarlos en un
map<string, pair< plugin*(*)(arg_pack*), errno_t(*)(plugin*)> >

a continuación, puede operaciones de búsqueda un plugin basado en un nombre (por encima de la cuerda) y conseguir que la 'constructor' o 'destructor'

ver también: gmodule

Answer 2

No puede cargar clases en tiempo de ejecución ya que C++ es un lenguaje compilado y las clases no existen en tiempo de ejecución. Los objetos (instancias de clases) lo hacen.

Lo que puede hacer es cargar bibliotecas compartidas en tiempo de ejecución y hacer que creen objetos de una determinada interfaz.

La implementación mínima del complemento definiría la interfaz de su complemento y la interfaz de la función de fábrica que va a crear objetos con esa interfaz. Va a cargar la biblioteca compartida en tiempo de ejecución, buscar la función de fábrica con un cierto nombre y llamar a la función de fábrica para crear un objeto. Luego utiliza ese objeto a través de la interfaz:

// 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(); 
}