Linux의 C ++ 동적 공유 라이브러리 정의 된 클래스의 객체를 생성하기위한 심볼을로드하는

이것은 g ++을 사용한 Dynamic Shared Library 컴파일에 대한 후속 조치 입니다.

Linux에서 C ++로 공유 클래스 라이브러리를 만들려고합니다. 라이브러리를 컴파일 할 수 있으며 here 및 here 에서 찾은 자습서를 사용하여 (비 클래스) 함수 중 일부를 호출 할 수 있습니다 . 라이브러리에 정의 된 클래스를 사용하려고하면 문제가 시작됩니다. 내가 링크 한 두 번째 튜토리얼은 라이브러리에 정의 된 클래스의 객체를 생성하기위한 심볼을로드하는 방법을 보여 주지만 해당 객체를 사용하여 작업을 완료하는 데에는 시간이 걸리지 않습니다.

누구든지 별도의 실행 파일에서 해당 클래스 를 사용 하는 방법을 보여주는 공유 C ++ 클래스 라이브러리를 작성하기위한보다 완전한 자습서를 알고 있습니까? 객체 생성, 사용 (간단한 게터 및 세터가 훌륭함) 및 삭제가 환상적으로 보이는 매우 간단한 자습서입니다. 공유 클래스 라이브러리의 사용을 보여주는 오픈 소스 코드에 대한 링크 또는 참조도 동일합니다.

codelogic 과 nimrodm 의 답변이 효과가 있지만 이 질문을 한 이후 Beginning Linux Programming 의 사본을 선택 했으며 첫 번째 장에는 예제 C 코드와 정적 라이브러리와 공유 라이브러리를 만들고 사용하는 데 대한 좋은 설명이 있습니다. . 이 예는 해당 도서 의 이전 버전 에서 Google 도서 검색을 통해 제공됩니다 .

답변

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

Mac OS X에서 다음을 사용하여 컴파일하십시오.

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

Linux에서 다음을 사용하여 컴파일하십시오.

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

이것이 플러그인 시스템 인 경우 MyClass를 기본 클래스로 사용하고 필요한 모든 기능을 가상으로 정의합니다. 하고자 다음 MyClass의에서 파생 플러그인 저자는 virtuals에를 무시하고 구현 create_object하고 destroy_object. 기본 응용 프로그램은 어떤 식 으로든 변경할 필요가 없습니다.

답변

다음은 공유 클래스 라이브러리 shared. [h, cpp] 및 라이브러리를 사용하는 main.cpp 모듈의 예를 보여줍니다. 매우 간단한 예이며 makefile을 훨씬 더 잘 만들 수 있습니다. 그러나 작동하고 도움이 될 수 있습니다.

shared.h는 클래스를 정의합니다.

class myclass {
   int myx;

  public:

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

shared.cpp는 getx / setx 함수를 정의합니다.

#include "shared.h"

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

main.cpp는 클래스를 사용합니다.

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

libshared.so를 생성하고 공유 라이브러리와 main을 연결하는 makefile :

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

실제로 ‘main’을 실행하고 libshared.와 링크하려면로드 경로를 지정해야합니다 (또는 / usr / local / lib 또는 이와 유사한 경로에 배치).

다음은 현재 디렉토리를 라이브러리의 검색 경로로 지정하고 기본 (bash 구문)을 실행합니다.

export LD_LIBRARY_PATH=.
./main

프로그램이 libshared.so와 연결되어 있는지 확인하려면 ldd를 시도하십시오 :

LD_LIBRARY_PATH=. ldd main

내 기계에 인쇄 :

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

답변

기본적으로 공유 라이브러리에서 클래스를 사용하려는 코드에 클래스 헤더 파일을 포함시켜야합니다. 그런 다음 링크 할 때 ‘-l’플래그 를 사용하여 코드를 공유 라이브러리와 링크하십시오. 물론, 이것은 OS가 그것을 찾을 수있는 곳에 .so가 필요합니다. 3.5를 참조하십시오 . 공유 라이브러리 설치 및 사용

dlsym 사용은 컴파일 할 때 사용할 라이브러리를 모르는 경우에 사용됩니다. 그것은 여기의 경우처럼 들리지 않습니다. 어쩌면 혼란은 Windows가 컴파일 또는 런타임에 링크를 수행하든 (유사한 방법으로) 동적으로로드 된 라이브러리를 호출한다는 것입니다. 그렇다면 dlsym을 LoadLibrary와 동등한 것으로 생각할 수 있습니다.

라이브러리를 동적으로로드해야하는 경우 (즉, 플러그인) 이 FAQ 가 도움이됩니다.

답변

이전 답변 외에도 처리기 파괴에 대해 안전 하기 위해 RAII (Resource Acquisition Is Initialization) 관용구 를 사용해야한다는 사실에 대한 인식을 높이고 싶습니다 .

완전한 작업 예는 다음과 같습니다.

인터페이스 선언 : Interface.hpp:

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

using Base_creator_t = Base *(*)();

공유 라이브러리 컨텐츠 :

#include "Interface.hpp"

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

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

동적 공유 라이브러리 핸들러 : 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);
        }
    }
};

클라이언트 코드 :

#include "Derived_factory.hpp"

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

노트 :

  • 간결성을 위해 헤더 파일에 모든 것을 넣었습니다. 실제로는 코드를 파일 .hpp과 .cpp파일로 분할해야 합니다.
  • 단순화하기 위해 new/ delete과부하 를 처리하려는 경우를 무시했습니다 .

자세한 내용을 알 수있는 두 가지 명확한 기사 :

답변