C++ Dynamique de Bibliothèque Partagée sur Linux

La figure suivante montre un exemple d'une classe partagée la bibliothèque partagée.[h,rpc] et un main.cpp module à l'aide de la bibliothèque. C'est un exemple très simple et le makefile pourrait être beaucoup mieux. Mais il fonctionne et peut vous aider à:

partagé.h définit la classe:

class myclass {
   int myx;

  public:

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

shared.cpp définit la getx/setx fonctions:

#include "shared.h"

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

main.cpp utilise 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;
}

et le fichier makefile qui génère libshared.donc, et les liens principaux avec la bibliothèque partagée:

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

À l'exécution réelle "principal" et le lien avec libshared.donc vous aurez probablement besoin de spécifier le chemin de chargement (ou de le mettre dans /usr/local/lib ou similaire).

Le suivant spécifie le répertoire courant comme le chemin de recherche pour les bibliothèques et les pistes principales (bash syntaxe):

export LD_LIBRARY_PATH=.
./main

De voir que le programme est lié avec libshared.ainsi, vous pouvez essayer la commande ldd:

LD_LIBRARY_PATH=. ldd main

Imprime sur ma machine:

  ~/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)

Sur le dessus de réponses précédentes, je tiens à sensibiliser la population au fait que vous devez utiliser le RAII (Acquisition de Ressources Est d'Initialisation) idiom pour être sûr de gestionnaire de destruction.

Ici est un exemple de travail:

Déclaration d'Interface: Interface.hpp:

class Base {
public:
    virtual ~Base() {}
    virtual void foo() const = 0;
};

using Base_creator_t = Base *(*)();

Partagé le contenu de la bibliothèque:

#include "Interface.hpp"

class Derived: public Base {
public:
    void foo() const override {}
};

extern "C" {
Base * create() {
    return new Derived;
}
}

Dynamique partagée de la bibliothèque de gestionnaire: Derived_factory.hpp:

#include "Interface.hpp"
#include <dlfcn.h>

class Derived_factory {
public:
    Derived_factory() {
        handler = dlopen("libderived.so", RTLD_NOW);
        if (! handler) {
            throw std::runtime_error(dlerror());
        }
        Reset_dlerror();
        creator = reinterpret_cast<Base_creator_t>(dlsym(handler, "create"));
        Check_dlerror();
    }

    std::unique_ptr<Base> create() const {
        return std::unique_ptr<Base>(creator());
    }

    ~Derived_factory() {
        if (handler) {
            dlclose(handler);
        }
    }

private:
    void * handler = nullptr;
    Base_creator_t creator = nullptr;

    static void Reset_dlerror() {
        dlerror();
    }

    static void Check_dlerror() {
        const char * dlsym_error = dlerror();
        if (dlsym_error) {
            throw std::runtime_error(dlsym_error);
        }
    }
};

Code Client:

#include "Derived_factory.hpp"

{
    Derived_factory factory;
    std::unique_ptr<Base> base = factory.create();
    base->foo();
}

Remarque:

• J'ai tout mis dans les fichiers d'en-tête pour la concision. Dans la vraie vie, vous devez bien sûr diviser votre code entre .hpp et .cpp fichiers.
• Pour simplifier, j'ai ignoré le cas où vous souhaitez gérer un new/delete surcharge.

Deux articles pour obtenir plus de détails:

• C++ dlopen mini how-to
• C++ le Chargement Dynamique des Objets Partagés au moment de l'Exécution