Biblioteca compartilhada dinâmica C ++ no Linux

Este é um acompanhamento da compilação da Biblioteca Compartilhada Dinâmica com g ++ .

Estou tentando criar uma biblioteca de classes compartilhadas em C ++ no Linux. Consigo fazer a biblioteca compilar e posso chamar algumas das funções (sem classe) usando os tutoriais que encontrei aqui e aqui . Meus problemas começam quando tento usar as classes definidas na biblioteca. O segundo tutorial ao qual vinculei mostra como carregar os símbolos para criar objetos das classes definidas na biblioteca, mas deixa de usar esses objetos para realizar qualquer trabalho.

Alguém conhece um tutorial mais completo para criar bibliotecas de classes C ++ compartilhadas que também mostra como usar essas classes em um executável separado? Um tutorial muito simples que mostra a criação e o uso de objetos (getters e setters simples seriam bons) e a exclusão seria fantástica. Um link ou uma referência a algum código-fonte aberto que ilustra o uso de uma biblioteca de classes compartilhadas seria igualmente bom.

Embora as respostas de codelogic e nimrodm funcionem, eu só queria acrescentar que peguei uma cópia do Beginning Linux Programming desde que fiz essa pergunta, e seu primeiro capítulo tem exemplo de código C e boas explicações para criar e usar bibliotecas estáticas e compartilhadas . Esses exemplos estão disponíveis na Pesquisa de Livros do Google em uma edição mais antiga desse livro .

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

No Mac OS X, compile com:

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

No Linux, compile com:

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

Se fosse para um sistema de plug-ins, você usaria MyClass como classe base e definiria todas as funções necessárias virtuais. O autor do plugin derivaria do MyClass, substituiria os virtuais e implementaria create_objecte destroy_object. Seu aplicativo principal não precisaria ser alterado de forma alguma.

A seguir, mostra um exemplo de uma biblioteca de classes compartilhada compartilhada. [H, cpp] e um módulo main.cpp usando a biblioteca. É um exemplo muito simples e o makefile pode ser melhorado. Mas funciona e pode ajudá-lo:

shared.h define a classe:

class myclass {
   int myx;

  public:

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

shared.cpp define as funções getx / setx:

#include "shared.h"

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

main.cpp usa a 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 o makefile que gera libshared.so e vincula main com a biblioteca compartilhada:

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

Para executar 'main' e conectar-se com libshared.so, você provavelmente precisará especificar o caminho de carregamento (ou colocá-lo em / usr / local / lib ou similar).

A seguir, especifica o diretório atual como o caminho de pesquisa para bibliotecas e executa main (sintaxe do bash):

export LD_LIBRARY_PATH=.
./main

Para verificar se o programa está vinculado ao libshared.so, você pode tentar o ldd:

LD_LIBRARY_PATH=. ldd main

Imprime na minha máquina:

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

Basicamente, você deve incluir o arquivo de cabeçalho da classe no código em que deseja usar a classe na biblioteca compartilhada. Em seguida, ao vincular, use o sinalizador '-l' para vincular seu código à biblioteca compartilhada. Obviamente, isso requer que o .so esteja onde o sistema operacional possa encontrá-lo. Veja 3.5. Instalando e usando uma biblioteca compartilhada

O uso do dlsym é para quando você não sabe em tempo de compilação qual biblioteca deseja usar. Isso não parece ser o caso aqui. Talvez a confusão seja que o Windows chama as bibliotecas carregadas dinamicamente se você faz o vínculo no momento da compilação ou do tempo de execução (com métodos análogos)? Nesse caso, você pode pensar em dlsym como o equivalente a LoadLibrary.

Se você realmente precisar carregar dinamicamente as bibliotecas (ou seja, são plug-ins), então estas Perguntas frequentes devem ajudar.

Além das respostas anteriores, gostaria de aumentar a conscientização sobre o fato de que você deve usar o idioma RAII (Aquisição de Recursos É Inicialização) para estar seguro sobre a destruição do manipulador.

Aqui está um exemplo de trabalho completo:

Declaração de interface Interface.hpp::

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

using Base_creator_t = Base *(*)();

Conteúdo da biblioteca compartilhada:

#include "Interface.hpp"

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

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

Manipulador de biblioteca compartilhada dinâmica 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);
        }
    }
};

Código do cliente:

#include "Derived_factory.hpp"

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

Nota:

• Eu coloquei tudo nos arquivos de cabeçalho por concisão. Na vida real, é claro que você deve dividir seu código entre .hppe.cpp arquivos.
• Para simplificar, ignorei o caso em que você deseja lidar com uma new/ deletesobrecarga.

Dois artigos claros para obter mais detalhes:

• C ++ dlopen mini instruções
• Carregamento dinâmico C ++ de objetos compartilhados em tempo de execução