我正在查看.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中的函数。
我希望这个问题有道理，而且我再也不会咆哮一些错误的树了。
答案 0 :(得分：128)
LoadLibrary没有按照您的想法行事。它将DLL加载到当前进程的内存中，但它不神奇地导入其中定义的函数！这是不可能的，因为在编译时链接器解析函数调用，而在运行时调用LoadLibrary（请记住C ++是statically typed语言）。
您需要一个单独的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;
}
此外，您应该正确地export您的DLL函数。这可以这样做：
int __declspec(dllexport) __stdcall funci() {
// ...
}
正如Lundin指出的那样，如果你不再需要它，free the handle to the library是一种很好的做法。如果没有其他进程仍然保存同一DLL的句柄，这将导致它被卸载。
答案 1 :(得分：27)
除了已经发布的答案之外，我想我应该分享一个方便的技巧，用于通过函数指针将所有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;
最后，要将这些连接到之前的数组，请创建一个union：
typedef union
{
functions_struct by_type;
func_ptr_t func_ptr [DLL_FUNCTIONS_N];
} functions_union;
现在，您可以使用方便的循环从DLL加载所有函数，但可以通过by_type union成员调用它们。
但是，当然，输入类似
的东西有点麻烦 每当你想调用一个函数时， 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版本上都是可预测的。
另外，理论上可能会在union / struct中插入填充，这会导致一切都失败。但是，指针恰好与Windows中的对齐要求大小相同。 <{1}}确保结构/联合没有填充可能仍然有序。
答案 2 :(得分：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。我猜这个cpp可能是.h。但是您可以通过不同的方式来做到这一点。这种方法对我有用。
#include "../inc/sn_factory.cpp"