Comment appeler une fonction d'une bibliothèque partagée?

Quelle est la méthode la plus simple et la plus sûre manière d'appeler une fonction d'une bibliothèque partagée /dll? Je suis surtout intéressé à le faire sur linux, mais ce serait mieux si il y avait une plate-forme indépendante.

Quelqu'un pourrait-il fournir un exemple de code pour montrer comment faire le travail suivant, où l'utilisateur a compilé sa propre version de foo dans une bibliothèque partagée?

//function prototype, implementation loaded at runtime:
std::string foo(const std::string);

int main(int argc, char** argv) {
  LoadLibrary(argv[1]); //loads library implementing foo
  std::cout << "Result: " << foo("test");
  return 0;
}

BTW, je sais comment faire pour compiler le partagé lib (foo.so), j'ai juste besoin de savoir un moyen facile de le charger au moment de l'exécution.

OriginalL'auteur Frank | 2010-03-29

  1. 25

    REMARQUE: Vous êtes de passage des objets en C++ (dans ce cas chaînes de caractères STL) autour de la bibliothèque d'appels. Il est pas de standard C++ ABI à ce niveau, alors essayez d'éviter de porter des objets C++, ou de s'assurer que votre bibliothèque et votre programme ont été construits avec le même compilateur (idéalement le même compilateur sur la même machine, afin d'éviter toute subtile relatives à la configuration de surprises.)

    Ne pas oublier de déclarer votre exporté méthodes extern "C" à l'intérieur de votre bibliothèque de code.

    Le dessus ayant été dit, ici, c'est du code la mise en œuvre de ce que vous avez dit que vous voulez atteindre:

    typedef std::string (*foo_t)(const std::string);
foo_t foo = NULL;

...

# ifdef _WIN32
  HMODULE hDLL = ::LoadLibrary(szMyLib);
  if (!hDll) { /*error*/ }
  foo = (foo_t)::GetProcAddress(hDLL, "foo");
# else
  void *pLib = ::dlopen(szMyLib, RTLD_LAZY);
  if (!pLib) { /*error*/ }
  foo = (foo_t)::dlsym(pLib, "foo");
# endif
  if (!foo) { /*error*/ }

  ...

  foo("bar");

  ...

# ifdef _WIN32
  ::FreeLibrary(hDLL);
# else
  ::dlclose(pLib);
# endif

    Vous pouvez résumé cette plus:

    #ifdef _WIN32
#include <windows.h>
typedef HANDLE my_lib_t;
#else
#include <dlfcn.h>
typedef void* my_lib_t;
#endif

my_lib_t MyLoadLib(const char* szMyLib) {
# ifdef _WIN32
  return ::LoadLibraryA(szMyLib);
# else //_WIN32
  return ::dlopen(szMyLib, RTLD_LAZY);
# endif //_WIN32
}

void MyUnloadLib(my_lib_t hMyLib) {
# ifdef _WIN32
  return ::FreeLibrary(hMyLib);
# else //_WIN32
  return ::dlclose(hMyLib);
# endif //_WIN32
}

void* MyLoadProc(my_lib_t hMyLib, const char* szMyProc) {
# ifdef _WIN32
  return ::GetProcAddress(hMyLib, szMyProc);
# else //_WIN32
  return ::dlsym(hMyLib, szMyProc);
# endif //_WIN32
}

typedef std::string (*foo_t)(const std::string);
typedef int (*bar_t)(int);
my_lib_t hMyLib = NULL;
foo_t foo = NULL;
bar_t bar = NULL;

...

  if (!(hMyLib = ::MyLoadLib(szMyLib)) { /*error*/ }
  if (!(foo = (foo_t)::MyLoadProc(hMyLib, "foo")) { /*error*/ }
  if (!(bar = (bar_t)::MyLoadProc(hMyLib, "bar")) { /*error*/ }

  ...

  foo("bar");
  bar(7);

  ...

  ::MyUnloadLib(hMyLib);
    Si vous l'avez mentionné, qui en-tête à inclure sur Unix/Linux...
    Dans le second bloc de code.
    Ce sujet de la fonction name mangling en C++, ne serait-ce pas compliquer les choses? Aussi, que vous avez mal orthographié windows ici #include <sindows.h>
    bon point, j'ai ajouté un préambule traiter avec extern "C" etc.

    OriginalL'auteur vladr

  2. 1

    LoadLibrary est une fonction de Windows pour le chargement des Dll. Vous pouvez vérifier le symbole de l'existence avec GetProcAddress. Sur Linux/Unix, vous voulez dlopen/dlsym. Pour ce faire, dans la croix-plate-forme, vous pouvez écrire une fonction qui appelle une de ces méthodes à l'aide de pré-processeur, donc, quelque chose comme:

    int loadlibrary(char* library)
{
#ifdef _WIN32
    /* do windows code */

#endif
#ifdef _LINUX
    /* do linux code */

#endif
}

    C'est une façon de réaliser ce genre de chose. Vous pouvez également le faire en incluant un en-tête différent dans votre arborescence des sources de plate-forme spécifique implémentations de fonctions. C'est probablement une meilleure façon. Dans les deux cas, l'idée est d'extraire à partir de l'API sous-jacente.

    OriginalL'auteur

  3. 0

    Sur Linux, vous devez utiliser dlsym. Voir un exemple à la fin de la page.
    Sur La Fenêtre: GetProcAddress.

    OriginalL'auteur Sergei Kurenkov