DLL에서 동적으로 함수로드

.dll 파일을 조금 살펴보고 사용 방법을 이해하고 사용 방법을 이해하려고합니다.

funci ()라는 정수를 반환하는 함수가 포함 된 .dll 파일을 만들었습니다.

이 코드를 사용하여 .dll 파일을 프로젝트로 가져 왔습니다 (불만 사항 없음).

#include <windows.h>
#include <iostream>

int main() {
  HINSTANCE hGetProcIDDLL = LoadLibrary("C:\\Documents and Settings\\User\\Desktop  \\fgfdg\\dgdg\\test.dll");

  if (hGetProcIDDLL == NULL) {
    std::cout << "cannot locate the .dll file" << std::endl;
  } else {
    std::cout << "it has been called" << std::endl;
    return -1;
  }

  int a = funci();

  return a;
}

# funci function 

int funci() {
  return 40;
}

그러나 .dll을 가져온 것으로 생각되는이 .cpp 파일을 컴파일하려고 할 때 다음 오류가 발생합니다.

C:\Documents and Settings\User\Desktop\fgfdg\onemore.cpp||In function 'int main()':|
C:\Documents and Settings\User\Desktop\fgfdg\onemore.cpp|16|error: 'funci' was not     declared in this scope|
||=== Build finished: 1 errors, 0 warnings ===|

나는 .dll이 헤더 파일과 다르다는 것을 알고 있으므로 이와 같은 함수를 가져올 수 없다는 것을 알고 있지만 내가 시도한 것을 보여줄 수있는 최선의 방법입니다.

내 질문은 hGetProcIDDLL포인터를 사용 하여 .dll 내의 함수에 액세스하는 방법입니다.

이 질문이 의미가 있기를 바라며, 아직 잘못된 나무를 짖지 않습니다.

LoadLibrary당신이 생각하는대로하지 않습니다. DLL을 현재 프로세스의 메모리에로드하지만 정의 된 함수를 마술처럼 가져 오지는 않습니다 ! 함수 호출은 LoadLibrary런타임에 호출되는 동안 컴파일 타임에 링커에 의해 해결되므로 가능하지 않습니다 (C ++는 정적으로 형식화 된 언어 임을 기억하십시오 ).

동적으로로드 된 함수의 주소를 가져 오려면 별도의 WinAPI 함수가 필요합니다 GetProcAddress..

예

#include <windows.h>
#include <iostream>

/* Define a function pointer for our imported
 * function.
 * This reads as "introduce the new type f_funci as the type: 
 *                pointer to a function returning an int and 
 *                taking no arguments.
 *
 * Make sure to use matching calling convention (__cdecl, __stdcall, ...)
 * with the exported function. __stdcall is the convention used by the WinAPI
 */
typedef int (__stdcall *f_funci)();

int main()
{
  HINSTANCE hGetProcIDDLL = LoadLibrary("C:\\Documents and Settings\\User\\Desktop\\test.dll");

  if (!hGetProcIDDLL) {
    std::cout << "could not load the dynamic library" << std::endl;
    return EXIT_FAILURE;
  }

  // resolve function address here
  f_funci funci = (f_funci)GetProcAddress(hGetProcIDDLL, "funci");
  if (!funci) {
    std::cout << "could not locate the function" << std::endl;
    return EXIT_FAILURE;
  }

  std::cout << "funci() returned " << funci() << std::endl;

  return EXIT_SUCCESS;
}

또한 DLL에서 함수를 올바르게 내 보내야 합니다. 다음과 같이 할 수 있습니다.

int __declspec(dllexport) __stdcall funci() {
   // ...
}

Lundin이 언급했듯이 더 이상 필요하지 않으면 라이브러리 핸들을 해제하는 것이 좋습니다 . 이로 인해 다른 프로세스가 여전히 동일한 DLL에 대한 핸들을 보유하고 있지 않으면 언로드됩니다.

이미 게시 된 답변 외에도 각 함수에 대해 별도의 GetProcAddress 호출을 작성하지 않고 함수 포인터를 통해 모든 DLL 함수를 프로그램에로드하는 데 사용하는 편리한 트릭을 공유해야한다고 생각했습니다. 또한 OP에서 시도한대로 함수를 직접 호출하고 싶습니다.

일반 함수 포인터 유형을 정의하여 시작하십시오.

typedef int (__stdcall* func_ptr_t)();

사용되는 유형은 실제로 중요하지 않습니다. 이제 DLL에있는 함수의 양에 해당하는 해당 유형의 배열을 만듭니다.

func_ptr_t func_ptr [DLL_FUNCTIONS_N];

이 배열에는 DLL 메모리 공간을 가리키는 실제 함수 포인터를 저장할 수 있습니다.

다음 문제는 GetProcAddress함수 이름을 문자열로 예상 한다는 것 입니다. 따라서 DLL의 함수 이름으로 구성된 유사한 배열을 만듭니다.

const char* DLL_FUNCTION_NAMES [DLL_FUNCTIONS_N] = 
{
  "dll_add",
  "dll_subtract",
  "dll_do_stuff",
  ...
};

이제 루프에서 GetProcAddress ()를 쉽게 호출하고 각 함수를 해당 배열에 저장할 수 있습니다.

for(int i=0; i<DLL_FUNCTIONS_N; i++)
{
  func_ptr[i] = GetProcAddress(hinst_mydll, DLL_FUNCTION_NAMES[i]);

  if(func_ptr[i] == NULL)
  {
    // error handling, most likely you have to terminate the program here
  }
}

루프가 성공했다면 이제 우리가 가진 유일한 문제는 함수를 호출하는 것입니다. 이전의 함수 포인터 typedef는 도움이되지 않습니다. 각 함수에는 자체 서명이 있기 때문입니다. 이 문제는 모든 함수 유형을 포함하는 구조체를 생성하여 해결할 수 있습니다.

typedef struct
{
  int  (__stdcall* dll_add_ptr)(int, int);
  int  (__stdcall* dll_subtract_ptr)(int, int);
  void (__stdcall* dll_do_stuff_ptr)(something);
  ...
} functions_struct;

마지막으로 이전에 배열에 연결하려면 공용체를 만듭니다.

typedef union
{
  functions_struct  by_type;
  func_ptr_t        func_ptr [DLL_FUNCTIONS_N];
} functions_union;

이제 편리한 루프를 사용하여 DLL에서 모든 함수를로드 할 수 있지만 by_type공용체 멤버를 통해 호출 할 수 있습니다 .

하지만 물론 다음과 같은 것을 타이핑하는 것은 약간 부담 스럽습니다.

functions.by_type.dll_add_ptr(1, 1); 함수를 호출 할 때마다.

이것이 내가 이름에 "ptr"접미사를 추가 한 이유입니다. 나는 그것들을 실제 함수 이름과 다르게 유지하고 싶었습니다. 이제 일부 매크로를 사용하여 icky 구조체 구문을 매끄럽게 만들고 원하는 이름을 얻을 수 있습니다.

#define dll_add (functions.by_type.dll_add_ptr)
#define dll_subtract (functions.by_type.dll_subtract_ptr)
#define dll_do_stuff (functions.by_type.dll_do_stuff_ptr)

이제 프로젝트에 정적으로 연결된 것처럼 올바른 유형 및 매개 변수와 함께 함수 이름을 사용할 수 있습니다.

int result = dll_add(1, 1);

면책 조항 : 엄밀히 말하면 서로 다른 함수 포인터 간의 변환은 C 표준에 의해 정의되지 않으며 안전하지 않습니다. 그래서 공식적으로 제가 여기서하는 것은 정의되지 않은 행동입니다. 그러나 Windows 세계에서 함수 포인터는 유형에 관계없이 항상 동일한 크기이며 내가 사용한 모든 Windows 버전에서 이들 간의 변환을 예측할 수 있습니다.

또한 이론적으로 공용체 / 구조체에 패딩이 삽입되어 모든 것이 실패 할 수 있습니다. 그러나 포인터는 Windows의 정렬 요구 사항과 크기가 동일합니다. static_assert구조체 / 유니온에 패딩이 없는지 확인하는 A 는 여전히 순서가있을 수 있습니다.

이것은 정확히 뜨거운 주제는 아니지만 dll이 인스턴스를 만들고 DLL로 반환 할 수 있도록하는 팩토리 클래스가 있습니다. 내가 찾고 왔지만 정확히 찾을 수 없었습니다.

그것은 다음과 같이 불립니다.

IHTTP_Server *server = SN::SN_Factory<IHTTP_Server>::CreateObject();
IHTTP_Server *server2 =
      SN::SN_Factory<IHTTP_Server>::CreateObject(IHTTP_Server_special_entry);

여기서 IHTTP_Server는 다른 DLL 또는 동일한 DLL에서 생성 된 클래스에 대한 순수 가상 인터페이스입니다.

DEFINE_INTERFACE는 클래스 ID에 인터페이스를 제공하는 데 사용됩니다. 인터페이스 내부에 배치하십시오.

인터페이스 클래스는 다음과 같습니다.

class IMyInterface
{
    DEFINE_INTERFACE(IMyInterface);

public:
    virtual ~IMyInterface() {};

    virtual void MyMethod1() = 0;
    ...
};

헤더 파일은 다음과 같습니다.

#if !defined(SN_FACTORY_H_INCLUDED)
#define SN_FACTORY_H_INCLUDED

#pragma once

라이브러리는이 매크로 정의에 나열됩니다. 라이브러리 / 실행 파일 당 한 줄. 다른 실행 파일을 호출 할 수 있다면 멋질 것입니다.

#define SN_APPLY_LIBRARIES(L, A)                          \
    L(A, sn, "sn.dll")                                    \
    L(A, http_server_lib, "http_server_lib.dll")          \
    L(A, http_server, "")

그런 다음 각 dll / exe에 대해 매크로를 정의하고 해당 구현을 나열합니다. Def는 인터페이스의 기본 구현임을 의미합니다. 기본값이 아닌 경우이를 식별하는 데 사용되는 인터페이스의 이름을 제공합니다. 즉, 특수하고 이름은 IHTTP_Server_special_entry가됩니다.

#define SN_APPLY_ENTRYPOINTS_sn(M)                                     \
    M(IHTTP_Handler, SNI::SNI_HTTP_Handler, sn, def)                   \
    M(IHTTP_Handler, SNI::SNI_HTTP_Handler, sn, special)

#define SN_APPLY_ENTRYPOINTS_http_server_lib(M)                        \
    M(IHTTP_Server, HTTP::server::server, http_server_lib, def)

#define SN_APPLY_ENTRYPOINTS_http_server(M)

라이브러리가 모두 설정되면 헤더 파일은 매크로 정의를 사용하여 필요한 것을 정의합니다.

#define APPLY_ENTRY(A, N, L) \
    SN_APPLY_ENTRYPOINTS_##N(A)

#define DEFINE_INTERFACE(I) \
    public: \
        static const long Id = SN::I##_def_entry; \
    private:

namespace SN
{
    #define DEFINE_LIBRARY_ENUM(A, N, L) \
        N##_library,

이렇게하면 라이브러리에 대한 열거 형이 생성됩니다.

    enum LibraryValues
    {
        SN_APPLY_LIBRARIES(DEFINE_LIBRARY_ENUM, "")
        LastLibrary
    };

    #define DEFINE_ENTRY_ENUM(I, C, L, D) \
        I##_##D##_entry,

이것은 인터페이스 구현을위한 열거 형을 생성합니다.

    enum EntryValues
    {
        SN_APPLY_LIBRARIES(APPLY_ENTRY, DEFINE_ENTRY_ENUM)
        LastEntry
    };

    long CallEntryPoint(long id, long interfaceId);

이것은 팩토리 클래스를 정의합니다. 여기에는별로 없습니다.

    template <class I>
    class SN_Factory
    {
    public:
        SN_Factory()
        {
        }

        static I *CreateObject(long id = I::Id )
        {
            return (I *)CallEntryPoint(id, I::Id);
        }
    };
}

#endif //SN_FACTORY_H_INCLUDED

그러면 CPP는

#include "sn_factory.h"

#include <windows.h>

외부 진입 점을 만듭니다. Depends.exe를 사용하여 존재하는지 확인할 수 있습니다.

extern "C"
{
    __declspec(dllexport) long entrypoint(long id)
    {
        #define CREATE_OBJECT(I, C, L, D) \
            case SN::I##_##D##_entry: return (int) new C();

        switch (id)
        {
            SN_APPLY_CURRENT_LIBRARY(APPLY_ENTRY, CREATE_OBJECT)
        case -1:
        default:
            return 0;
        }
    }
}

매크로는 필요한 모든 데이터를 설정합니다.

namespace SN
{
    bool loaded = false;

    char * libraryPathArray[SN::LastLibrary];
    #define DEFINE_LIBRARY_PATH(A, N, L) \
        libraryPathArray[N##_library] = L;

    static void LoadLibraryPaths()
    {
        SN_APPLY_LIBRARIES(DEFINE_LIBRARY_PATH, "")
    }

    typedef long(*f_entrypoint)(long id);

    f_entrypoint libraryFunctionArray[LastLibrary - 1];
    void InitlibraryFunctionArray()
    {
        for (long j = 0; j < LastLibrary; j++)
        {
            libraryFunctionArray[j] = 0;
        }

        #define DEFAULT_LIBRARY_ENTRY(A, N, L) \
            libraryFunctionArray[N##_library] = &entrypoint;

        SN_APPLY_CURRENT_LIBRARY(DEFAULT_LIBRARY_ENTRY, "")
    }

    enum SN::LibraryValues libraryForEntryPointArray[SN::LastEntry];
    #define DEFINE_ENTRY_POINT_LIBRARY(I, C, L, D) \
            libraryForEntryPointArray[I##_##D##_entry] = L##_library;
    void LoadLibraryForEntryPointArray()
    {
        SN_APPLY_LIBRARIES(APPLY_ENTRY, DEFINE_ENTRY_POINT_LIBRARY)
    }

    enum SN::EntryValues defaultEntryArray[SN::LastEntry];
        #define DEFINE_ENTRY_DEFAULT(I, C, L, D) \
            defaultEntryArray[I##_##D##_entry] = I##_def_entry;

    void LoadDefaultEntries()
    {
        SN_APPLY_LIBRARIES(APPLY_ENTRY, DEFINE_ENTRY_DEFAULT)
    }

    void Initialize()
    {
        if (!loaded)
        {
            loaded = true;
            LoadLibraryPaths();
            InitlibraryFunctionArray();
            LoadLibraryForEntryPointArray();
            LoadDefaultEntries();
        }
    }

    long CallEntryPoint(long id, long interfaceId)
    {
        Initialize();

        // assert(defaultEntryArray[id] == interfaceId, "Request to create an object for the wrong interface.")
        enum SN::LibraryValues l = libraryForEntryPointArray[id];

        f_entrypoint f = libraryFunctionArray[l];
        if (!f)
        {
            HINSTANCE hGetProcIDDLL = LoadLibraryA(libraryPathArray[l]);

            if (!hGetProcIDDLL) {
                return NULL;
            }

            // resolve function address here
            f = (f_entrypoint)GetProcAddress(hGetProcIDDLL, "entrypoint");
            if (!f) {
                return NULL;
            }
            libraryFunctionArray[l] = f;
        }
        return f(id);
    }
}

각 라이브러리에는 각 라이브러리 / 실행 파일에 대한 스텁 cpp와 함께이 "cpp"가 포함됩니다. 특정 컴파일 된 헤더 항목.

#include "sn_pch.h"

이 라이브러리를 설정하십시오.

#define SN_APPLY_CURRENT_LIBRARY(L, A) \
    L(A, sn, "sn.dll")

메인 cpp에 대한 포함. 나는이 cpp가 .h 일 수 있다고 생각합니다. 그러나 이것을 할 수있는 다른 방법이 있습니다. 이 접근 방식은 저에게 효과적이었습니다.

#include "../inc/sn_factory.cpp"