如何在C++中创建一个动态链接库_C++动态链接库（DLL）创建与使用

创建C++动态链接库需使用__declspec(dllexport)标记导出函数，并通过头文件和宏定义区分导出与导入，编译生成.dll和.lib文件；使用时可通过隐式链接（自动加载）或显式链接（运行时动态加载）调用DLL功能，解决模块化、代码复用与内存效率问题。

在C++中创建一个动态链接库（DLL）的核心在于，你需要明确地告诉编译器哪些函数或类是打算被外部程序调用的。这通常通过特定的关键字实现，例如在Windows平台上是

__declspec(dllexport)

解决方案

要创建一个C++动态链接库，我们通常会经历以下几个步骤。这不仅仅是技术操作，更是一种模块化思维的体现，把你的功能封装起来，让其他项目能够方便地复用。

首先，你需要定义你的DLL接口。这通常在一个头文件（例如

MyDLL.h

__declspec(dllexport)

__declspec(dllimport)

dllimport

MyDLL.h

立即学习“C++免费学习笔记（深入）”；

#ifdef MYDLL_EXPORTS
#define MYDLL_API __declspec(dllexport)
#else
#define MYDLL_API __declspec(dllimport)
#endif

// 确保C++编译器不会对这些函数进行名称修饰
// 这对于C语言或其他语言调用DLL函数尤其重要
extern "C" {
    MYDLL_API int Add(int a, int b);
    MYDLL_API void PrintMessage();
}

// 导出C++类，需要注意名称修饰问题
class MYDLL_API MyClass {
public:
    MyClass();
    void Greet();
    int Multiply(int a, int b);
};

接下来，在你的源文件（例如

MyDLL.cpp

MYDLL_EXPORTS

MYDLL_API

__declspec(dllexport)

MyDLL.cpp

#define MYDLL_EXPORTS // 编译DLL时定义此宏

#include "MyDLL.h"
#include 

extern "C" {
    int Add(int a, int b) {
        return a + b;
    }

    void PrintMessage() {
        std::cout << "Hello from MyDLL!" << std::endl;
    }
}

MyClass::MyClass() {
    std::cout << "MyClass instance created in DLL." << std::endl;
}

void MyClass::Greet() {
    std::cout << "Greetings from MyClass in DLL!" << std::endl;
}

int MyClass::Multiply(int a, int b) {
    return a * b;
}

最后一步是编译。 如果你使用 MSVC (Visual Studio)：

1. 创建一个“动态链接库（DLL）”项目。
2. 将

   MyDLL.h

   和

   MyDLL.cpp

   添加到项目中。
3. 编译项目，它会生成

   MyDLL.dll

   和

   MyDLL.lib

   。

如果你使用 MinGW/GCC： 你可以使用命令行编译。

g++ -c MyDLL.cpp -o MyDLL.o -D MYDLL_EXPORTS # 编译源文件
g++ -shared -o MyDLL.dll MyDLL.o -Wl,--out-implib,MyDLL.lib # 链接生成DLL和导入库

这里的

-D MYDLL_EXPORTS

-shared

-Wl,--out-implib,MyDLL.lib

至此，你的DLL就创建完成了。接下来的挑战就是如何让其他应用程序正确地使用它。

为什么我们要用动态链接库？（以及它到底解决了什么痛点）

说实话，我最初接触DLL的时候，觉得它把事情搞得有点复杂，多了一个文件，多了一些编译步骤。但随着项目规模的增长，我才真正体会到它的价值。最核心的，DLL解决了软件开发的“模块化”和“资源共享”两大痛点。

想象一下，你有一个庞大的应用程序，里面有几十个甚至上百个模块。如果所有代码都编译成一个巨大的可执行文件，每次修改哪怕一个很小的功能，你都得重新编译整个程序，这效率简直是灾难。DLL就像是把这些模块拆分成独立的“积木”，每个积木可以独立开发、独立编译、独立更新。我个人觉得最舒服的，就是那种项目变得可插拔的感觉。比如，我可以为我的应用程序开发一个插件系统，每个插件就是一个DLL，用户可以根据需要加载或卸载，而不需要我重新发布整个应用程序。这极大地提升了软件的灵活性和可维护性。

再者，资源共享也是一个大头。多个应用程序如果都使用了同一套底层功能（比如一个图形渲染库或者一个数据库访问模块），如果这些功能都静态链接到每个应用程序里，那么每个应用程序运行时都会在内存中加载一份相同的代码副本。而使用DLL，这份代码只需要在内存中加载一次，所有使用它的程序都可以共享。这在系统资源有限的情况下，能显著减少内存占用，提升系统整体效率。虽然现代计算机内存普遍较大，但这依然是一个优雅的解决方案，尤其是在部署和分发时，可以减少应用程序的体积。

创建DLL时，有哪些“坑”是新手常踩的？

创建DLL这事儿，看起来直截了当，但实际操作起来，总有些小细节能把人搞得头大。我刚开始的时候，就没少在这些“坑”里打滚。

最大的一个问题，我觉得就是导出符号问题。你明明写了函数，也编译了DLL，结果调用方就是“找不到符号”。这多半是忘记了

__declspec(dllexport)

dllexport

dllimport

int Add(int a, int b)

?Add@@YAHHH@Z

extern "C"

extern "C"

MVM mall 网上购物系统

采用 php+mysql 数据库方式运行的强大网上商店系统，执行效率高速度快，支持多语言，模板和代码分离，轻松创建属于自己的个性化用户界面 v3.5更新： 1).进一步静态化了活动商品. 2).提供了一些重要UFT-8转换文件 3).修复了除了网银在线支付其它支付显示错误的问题. 4).修改了LOGO广告管理,增加LOGO链接后主页LOGO路径错误的问题 5).修改了公告无法发布的问题,可能是打压

下载

另一个常见的陷阱是调用约定不匹配。在Windows上，常见的有

__cdecl

__stdcall

__cdecl

__stdcall

__stdcall

__cdecl

再来就是运行时库不一致。如果你用Visual Studio开发，Debug版本和Release版本，或者使用MT（静态链接运行时库）和MD（动态链接运行时库）的DLL和调用程序，它们的运行时库版本必须一致。否则，当你尝试在DLL和主程序之间传递STL对象（如

std::string

std::vector

最后，别忘了DLL Hell。虽然现在Windows系统在这方面做得更好了，但不同版本的DLL文件可能会相互覆盖，导致某些程序崩溃。这提醒我们，部署DLL时要特别小心，尽量使用独立的应用程序目录，或者确保版本兼容性。

如何在C++应用程序中正确加载和使用DLL？

创建好DLL之后，下一步就是如何在你的C++应用程序中“消费”它。这主要有两种方式：隐式链接和显式链接。我通常会根据项目需求来决定用哪种方式，各有优劣。

1. 隐式链接（Implicit Linking）

这是最简单、最常用的方式，感觉就像在用一个普通的静态库一样。在编译你的应用程序时，你需要告诉链接器去链接DLL对应的导入库（

.lib

步骤：

1. 包含头文件： 在你的应用程序代码中包含DLL的头文件（

   MyDLL.h

   ）。确保头文件中的

   MYDLL_API

   宏被正确地扩展为

   __declspec(dllimport)

   （即不要定义

   MYDLL_EXPORTS

   ）。
2. 链接导入库： 在你的项目设置中，将DLL生成的

   .lib

   文件添加到链接器的输入中。
   • MSVC: 在项目属性 -> 链接器 -> 输入 -> 附加依赖项中添加

     MyDLL.lib

     。
   • GCC/MinGW: 在编译命令中加入

     -L -lMyDLL

     。
   • 或者，在代码中使用

     #pragma comment(lib, "MyDLL.lib")

     (仅限MSVC)。
3. 部署DLL： 确保

   MyDLL.dll

   文件在应用程序的可执行文件同目录下，或者在系统的PATH环境变量指定的路径中，以便操作系统能够找到并加载它。

示例代码：

// 应用程序代码 (MyApp.cpp)
#include "MyDLL.h" // 此时MYDLL_API 会被定义为 __declspec(dllimport)
#include 

#pragma comment(lib, "MyDLL.lib") // 告诉MSVC链接MyDLL.lib

int main() {
    // 调用DLL导出的C函数
    int result = Add(5, 3);
    std::cout << "Add(5, 3) = " << result << std::endl;
    PrintMessage();

    // 使用DLL导出的C++类
    MyClass myObj;
    myObj.Greet();
    int product = myObj.Multiply(4, 2);
    std::cout << "Multiply(4, 2) = " << product << std::endl;

    return 0;
}

优点： 使用起来非常方便，就像调用本地函数一样自然。 缺点： 应用程序在启动时就强依赖于DLL。如果DLL文件不存在或版本不匹配，应用程序将无法启动。

2. 显式链接（Explicit Linking）

这种方式更为灵活，你可以在运行时动态地加载DLL，并在不需要时卸载它。这对于实现插件系统或者处理可选功能模块非常有用。

步骤：

1. 加载DLL： 使用

   LoadLibrary

   (Windows) 或

   dlopen

   (Linux/macOS) 函数加载DLL。
2. 获取函数地址： 使用

   GetProcAddress

   (Windows) 或

   dlsym

   (Linux/macOS) 函数获取你想要调用的函数或类的入口点。这需要你将函数指针声明为正确的类型。
3. 调用函数： 通过获取到的函数指针进行调用。
4. 卸载DLL： 当不再需要DLL时，使用

   FreeLibrary

   (Windows) 或

   dlclose

   (Linux/macOS) 卸载它。

示例代码 (Windows)：

// 应用程序代码 (MyApp_Explicit.cpp)
#include  // For LoadLibrary, GetProcAddress, FreeLibrary
#include 

// 定义函数指针类型，匹配DLL中导出的函数签名
typedef int (*AddFunc)(int, int);
typedef void (*PrintMessageFunc)();
// 对于C++类，显式链接会更复杂，通常会导出工厂函数来创建对象
// 比如：typedef MyClass* (*CreateMyClassFunc)();
//       typedef void (*DestroyMyClassFunc)(MyClass*);


int main() {
    HMODULE hDLL = LoadLibrary(TEXT("MyDLL.dll")); // 加载DLL

    if (hDLL != NULL) {
        // 获取Add函数的地址
        AddFunc pAdd = (AddFunc)GetProcAddress(hDLL, "Add"); // 注意：这里是原始的函数名，因为我们使用了extern "C"

        // 获取PrintMessage函数的地址
        PrintMessageFunc pPrintMessage = (PrintMessageFunc)GetProcAddress(hDLL, "PrintMessage");

        if (pAdd != NULL && pPrintMessage != NULL) {
            int result = pAdd(10, 20);
            std::cout << "Explicit Link: Add(10, 20) = " << result << std::endl;
            pPrintMessage();
        } else {
            std::cerr << "Error: Could not find function in DLL." << std::endl;
        }

        FreeLibrary(hDLL); // 卸载DLL
    } else {
        std::cerr << "Error: Could not load MyDLL.dll. GetLastError(): " << GetLastError() << std::endl;
    }

    return 0;
}

优点： 极高的灵活性，可以动态加载/卸载DLL，实现插件、热更新等功能。应用程序启动时不会强依赖DLL，即使DLL不存在也能正常启动（只是相关功能不可用）。 缺点： 代码相对复杂，需要手动管理DLL的生命周期，并且对于C++类和其成员函数的导出和调用，处理起来会更加繁琐（通常需要导出工厂函数和销毁函数）。

选择哪种方式，真的得看你的具体场景。如果是一个核心功能，DLL是应用程序不可或缺的一部分，隐式链接会更方便。如果是一个可插拔的模块，或者你需要在运行时决定是否加载某个功能，那么显式链接就是你的不二之选。