从DLL动态加载功能

88

我稍微看一下.dll文件，了解它们的用法，并试图了解如何使用它们。

我创建了一个.dll文件，其中包含一个函数，该函数返回一个名为funci（）的整数

使用此代码，我（认为）我已将.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中的函数。

我希望这个问题有道理，而且我不会再提出错误的建议了。

c++  winapi  dll 
— 宽大
source
查找静态/动态链接。
— 米奇小麦
谢谢您，我将对此进行研究
我缩进了代码，但是当我将其缩进这里时，格式变得混乱了，所以最终缩进了4行

Answers:

152

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的句柄，这将导致它被卸载。

— 尼克拉斯B.
source
可能听起来像一个愚蠢的问题，但是f_funci的类型/应该是什么？
8
除此之外，答案是极好的并且易于理解
6
请注意，f_funci实际上是一种类型（而不是具有类型）。该类型f_funci读取为“指向返回anint并且不带参数的函数的指针”。有关C语言中函数指针的更多信息，请参见newty.de/fpt/index.html。
— Niklas B. 2012年
再次感谢您的答复，funci不接受任何参数并返回整数；我编辑了问题以显示已编译的功能？进入.dll。当我尝试在包含“ typedef int（f_funci）（）;”之后运行时 我收到此错误：C：\ Documents and Settings \ User \ Desktop \ fgfdg \ onemore.cpp ||在函数'int main（）'：|中 C：\ Documents and Settings \ User \ Desktop \ fgfdg \ onemore.cpp | 18 |错误：无法将参数'2'的'int（）（）'转换为'const CHAR *'到'int（* GetProcAddress（HINSTANCE__ ， const CHAR））（）'| || ===构建完成：1个错误，0个警告=== |
好吧，我忘了在那里的演员表（对其进行编辑）。但是该错误似乎是另一个错误，您确定使用正确的代码吗？如果是，您能否将失败的代码和完整的编译器输出粘贴到pastie.org上？另外，您在评论中输入的typedef是错误的（*缺少一个，可能导致该错误）
— Niklas B.
34

除了已经发布的答案之外，我认为我应该分享一个方便的技巧，该技巧用于通过函数指针将所有DLL函数加载到程序中，而无需为每个函数编写单独的GetProcAddress调用。我还喜欢直接在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，以确保结构/联合没有填充可能是为了还。

— 伦丁
source
1
这种C风格的方法会起作用。但是使用C ++构造来避免#defines是否不合适？
— 哈珀2014年
@harper在C ++ 11中，您可以使用auto dll_add = ...，但是在C ++ 03中，没有可以想到的结构可以简化任务（我也看不到#defines的任何特殊问题）
— NiklasB。
由于这都是WinAPI特有的，因此您无需自己输入typedef func_ptr_t。相反，您可以使用FARPROC，这是的返回类型GetProcAddress。这样可以使您编译时具有更高的警告级别，而无需在GetProcAddress调用中添加强制类型转换。
— 阿德里安·麦卡锡
@NiklasB。您一次只能使用auto一个功能，这使一次循环全部执行一次的想法破了。但是数组std :: function有什么问题
— Francesco Dondi
1
@Francesco std :: function类型将与funcptr类型一样。我想可变参数模板会有所帮助
— Niklas B.
1

这并不是一个热门话题，但是我有一个工厂类，该类允许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的一个include。我猜这个cpp可能是.h。但是您可以通过不同的方式来做到这一点。这种方法对我有用。

#include "../inc/sn_factory.cpp"
— 彼得·德里斯科尔
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.