Question

This is a follow-up to Dynamic Shared Library compilation with g++.

I’m trying to create a shared class library in C++ on Linux. I’m able to get the library to compile, and I can call some of the (non-class) functions using the tutorials that I found here and here. My problems start when I try to use the classes that are defined in the library. The second tutorial that I linked to shows how to load the symbols for creating objects of the classes defined in the library, but stops short of using those objects to get any work done.

Does anyone know of a more complete tutorial for creating shared C++ class libraries that also shows how to use those classes in a separate executable? A very simple tutorial that shows object creation, use (simple getters and setters would be fine), and deletion would be fantastic. A link or a reference to some open source code that illustrates the use of a shared class library would be equally good.

---

Although the answers from codelogic and nimrodm do work, I just wanted to add that I picked up a copy of Beginning Linux Programming since asking this question, and its first chapter has example C code and good explanations for creating and using both static and shared libraries. These examples are available through Google Book Search in 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 ); } 

On Mac OS X, compile with:

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

On Linux, compile with:

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

If this were for a plugin system, you would use MyClass as a base class and define all the required functions virtual. The plugin author would then derive from MyClass, override the virtuals and implement create_object and destroy_object. Your main application would not need to be changed in any way.