Libreria condivisa dinamica C++ su Linux

Question

Questo è un seguito di Dynamic Shared Library compilation with g++.

Sto provando a creare una libreria di classi condivisa in C++ su Linux. Sono in grado di compilare la libreria e posso chiamare alcune delle funzioni (non di classe) utilizzando le esercitazioni che ho trovato here e here. I miei problemi iniziano quando provo ad usare le classi che sono definite nella libreria. Il secondo tutorial che ho collegato mostra come caricare i simboli per creare oggetti delle classi definite nella libreria, ma si ferma a breve di usando gli oggetti per eseguire qualsiasi lavoro.

Qualcuno sa di un tutorial più completo per la creazione di librerie di classi C++ condivise che mostra anche come utilizzare quelle classi in un file eseguibile separato? Un tutorial molto semplice che mostra la creazione di oggetti, l'uso (getter e setter semplici andrebbero bene), e la cancellazione sarebbe fantastica. Un link o un riferimento ad un codice open source che illustri l'uso di una libreria di classi condivise sarebbe altrettanto valido.

---

Anche se le risposte da codelogic e nimrodm funzionano, volevo solo aggiungere che ho preso in mano una copia di Beginning Linux Programming poiché questa domanda, e il suo primo capitolo ha codice di esempio C e buone spiegazioni per la creazione e l'utilizzo di entrambe le librerie statiche e condivise. Questi esempi sono disponibili tramite Google Ricerca Libri nello an older edition of that book.

Answer 1

MyClass.h

#ifndef __MYCLASS_H__ 
#define __MYCLASS_H__ 

class MyClass 
{ 
public: 
    MyClass(); 

    /* use virtual otherwise linker will try to perform static linkage */ 
    virtual void DoSomething(); 

private: 
    int x; 
}; 

#endif 

myclass.cc

#include "myclass.h" 
#include <iostream> 

using namespace std; 

extern "C" MyClass* create_object() 
{ 
    return new MyClass; 
} 

extern "C" void destroy_object(MyClass* object) 
{ 
    delete object; 
} 

MyClass::MyClass() 
{ 
    x = 20; 
} 

void MyClass::DoSomething() 
{ 
    cout<<x<<endl; 
} 

class_user.cc

#include <dlfcn.h> 
#include <iostream> 
#include "myclass.h" 

using namespace std; 

int main(int argc, char **argv) 
{ 
    /* on Linux, use "./myclass.so" */ 
    void* handle = dlopen("myclass.so", RTLD_LAZY); 

    MyClass* (*create)(); 
    void (*destroy)(MyClass*); 

    create = (MyClass* (*)())dlsym(handle, "create_object"); 
    destroy = (void (*)(MyClass*))dlsym(handle, "destroy_object"); 

    MyClass* myClass = (MyClass*)create(); 
    myClass->DoSomething(); 
    destroy(myClass); 
} 

In Mac OS X, compilare con:

g++ -dynamiclib -flat_namespace myclass.cc -o myclass.so 
g++ class_user.cc -o class_user 

Su Linux, la compilazione con:

g++ -fPIC -shared myclass.cc -o myclass.so 
g++ class_user.cc -ldl -o class_user 

Se questo fosse per un sistema di plugin, si usa MyClass come classe base e definire tutte le funzioni necessarie virtuale. L'autore del plug-in verrebbe quindi derivato da MyClass, sovrascrive i virtual e implementa create_object e destroy_object. La tua applicazione principale non dovrebbe essere modificata in alcun modo.

Answer 2

Quanto segue mostra un esempio di libreria di classi condivise condivisa. [H, cpp] e un modulo main.cpp che utilizza la libreria. È un esempio molto semplice e il makefile potrebbe essere migliorato molto meglio. Ma funziona e può aiutare a:

shared.h definisce la classe:

class myclass { 
    int myx; 

    public: 

    myclass() { myx=0; } 
    void setx(int newx); 
    int getx(); 
}; 

shared.cpp definisce le GetX/setx funzioni:

#include "shared.h" 

void myclass::setx(int newx) { myx = newx; } 
int myclass::getx() { return myx; } 

main.cpp utilizza la classe,

#include <iostream> 
#include "shared.h" 

using namespace std; 

int main(int argc, char *argv[]) 
{ 
    myclass m; 

    cout << m.getx() << endl; 
    m.setx(10); 
    cout << m.getx() << endl; 
} 

e il makefile che genera libshared.so e collega principale con la libreria condivisa:

main: libshared.so main.o 
    $(CXX) -o main main.o -L. -lshared 

libshared.so: shared.cpp 
    $(CXX) -fPIC -c shared.cpp -o shared.o 
    $(CXX) -shared -Wl,-soname,libshared.so -o libshared.so shared.o 

clean: 
    $rm *.o *.so 

per l'esecuzione effettiva 'main' e legame con libshared.so si avrà probabilmente bisogno di specificare il percorso di carico (o metterlo in/usr/local/lib o simili).

Di seguito specifica la directory corrente come percorso di ricerca per le biblioteche e corre principale (sintassi bash):

export LD_LIBRARY_PATH=. 
./main 

di vedere che il programma è collegato con libshared.so si può provare LDD:

LD_LIBRARY_PATH=. ldd main 

Stampe sulla mia macchina:

~/prj/test/shared$ LD_LIBRARY_PATH=. ldd main 
    linux-gate.so.1 => (0xb7f88000) 
    libshared.so => ./libshared.so (0xb7f85000) 
    libstdc++.so.6 => /usr/lib/libstdc++.so.6 (0xb7e74000) 
    libm.so.6 => /lib/libm.so.6 (0xb7e4e000) 
    libgcc_s.so.1 => /usr/lib/libgcc_s.so.1 (0xb7e41000) 
    libc.so.6 => /lib/libc.so.6 (0xb7cfa000) 
    /lib/ld-linux.so.2 (0xb7f89000) 

Answer 3

in sostanza, si dovrebbe includere i clas s 'il file di intestazione nel codice in cui si desidera utilizzare la classe nella libreria condivisa. Quindi, quando si collega, use the '-l' flag per collegare il codice con la libreria condivisa. Ovviamente, ciò richiede che sia .so dove si trova il sistema operativo.Vedi 3.5. Installing and Using a Shared Library

L'utilizzo di dlsym è utile quando non si conosce in fase di compilazione quale libreria si desidera utilizzare. Non sembra che sia il caso qui. Forse la confusione è che Windows chiama le librerie caricate dinamicamente sia che si esegua il collegamento in fase di compilazione sia in fase di esecuzione (con metodi analoghi)? Se è così, allora puoi pensare a dlsym come l'equivalente di LoadLibrary.

Se è davvero necessario caricare dinamicamente le librerie (vale a dire, sono plug-in), quindi this FAQ dovrebbe essere d'aiuto.