动态链接库

1. 动态链接库的分类

　　Visual C++支持三种DLL，它们分别是Non-MFC DLL(非MFC动态库)、 MFC Regular DLL(MFC规则DLL)、 MFC Extension DLL(MFC扩展DLL)。

　　(1) 非MFC动态库：不采用MFC类库结构，其导出函数为标准的C接口，能被非MFC或MFC编写的应用程序所调用。

　　(2) MFC规则DLL：包含一个继承自CWinApp的类，但其无消息循环。

　　(3) MFC扩展DLL：采用MFC的动态链接版本创建，它只能被用MFC类库所编写的应用程序所调用。

2. DLL中导出函数的声明方式

　　一种方式是：在函数声明中加上__declspec(dllexport)。
　　另外一种方式是：采用模块定义(.def)文件声明，(.def)文件为链接器提供了有关被链接程序的导出、属性及其他方面的信息。

　　(1) 方式一：在函数声明中加上__declspec(dllexport)

#pragma once

extern "C" __declspec(dllexport) int add(int x, int y);

#include "stdafx.h"
#include "dllTest.h"

int add(int x, int y)
{
    return (x + y);
}

 　　(2) 方式二：采用模块定义(.def)文件声明

　　　　①首先创建 一个DLL程序(DllTestDef)

　　　　②在*.cpp中添加需要导出的接口函数

#include "stdafx.h"

int __stdcall Add(int a, int b)
{
    return (a + b);
}

int _stdcall Sub(int a, int b)
{
    return (a - b);
}

 　　　　③然后创建一个.def的文件

LIBRARY dllTest
EXPORTS
Add @ 1
Sub @ 2

3. DLL的调用方式

　　(1)动态调用：

　　　　"LoadLibrary-GetProcAddress-FreeLibrary"系统API提供的三位一体"DLL加载-DLL函数地址获取-DLL释放"方式，这种调用方式称为DLL的动态调用。

#include "stdafx.h"
#include <iostream>
using namespace std;
#include <windows.h>

typedef int(*lpAdd)(int, int);
typedef int(*lpSub)(int, int);

int main()
{
    HMODULE hDll = NULL;
    lpAdd pAdd = NULL;
    lpSub pSub = NULL;

    hDll = LoadLibrary(TEXT("dllTest.dll"));
    if (hDll != NULL)
    {
        pAdd = (lpAdd)GetProcAddress(hDll, "Add");
        pSub = (lpSub)GetProcAddress(hDll, "Sub");

        if (pAdd != NULL)
        {
            cout << "3 + 5 = " << pAdd(3, 5) << endl;
        }

        if (pSub != NULL)
        {
            cout << "2 + 4 = " << pSub(2, 4) << endl;
        }
    }

    getchar();
    return 0;
}

 　　(2)静态调用：

　　　　静态调用，也称为隐式调用，由编译系统完成对DLL的加载和应用程序结束时DLL卸载的编码(Windows系统负责对DLL调用次数的计数)，调用方式简单，能够满足通常的要求。通常采用的调用方式是把产生动态连接库时产生的.LIB文件加入到应用程序的工程中，想使用DLL中的函数时，只须在源文件中声明一下。

#include "stdafx.h"
#include <iostream>
using namespace std;

#pragma comment(lib, "..\x64\Release\dllTest.lib")
extern "C" __declspec(dllimport) int add(int x, int y);

int main()
{
    cout << "4 + 7 = " << add(4, 7) << endl;

    getchar();
    return 0;
}

 4. DllMain函数

    Windows在加载DLL的时候，需要一个入口函数，如同控制台或 DOS 程序需要 main 函数、WIN32程序需要 WinMain 函数一样。

    在前面的例子中，DLL并没有提供 DllMain函数， 应用工程也能成功引用 DLL，这是因为Windows在找不到DllMain的时候， 系统会从其它运行库中引入一个不做任何操作的缺省 DllMain函数版本，并不意味着 DLL可以放弃 DllMain函数。

    根据编写规范， Windows必须查找并执行 DLL里的 DllMain函数作为加载 DLL的依据，它使得 DLL得以保留在内存里。这个函数并不属于导出函数，而是 DLL 的内部函数。这意味着不能直接在应用工程中引用 DllMain函数， DllMain是自动被调用的 。

BOOL APIENTRY DllMain( HMODULE hModule,
                       DWORD  ul_reason_for_call,
                       LPVOID lpReserved
                     )
{
    switch (ul_reason_for_call)
    {
    case DLL_PROCESS_ATTACH:
    case DLL_THREAD_ATTACH:
    case DLL_THREAD_DETACH:
    case DLL_PROCESS_DETACH:
        break;
    }
    return TRUE;
}

  5. 关于调用约定

　　C/C++缺省的调用方式是__cdecl方式，Windows API使用__stdcall调用方式，在DLL导出函数中，为了跟Windows API保持一致，建议使用__stdcall调用方式。

        __cdecl方式与__stdcall对函数名最终生成符号的方式不同。若采用C编译方式(在C++中需将函数声明为extern "C")。

　　__stdcall调用约定在输出函数名钱加下划线，后面加“@”符号和参数的字节数，形如_functionname@number；

　　而__cdecl调用约定仅在输出函数名前加下划线，形如_functionname。

6. DLL导出变量

     DLL定义的全局变量可以被调用进程访问，DLL也可以访问调用进程的全局数据。

    (1) 在DLL中导出变量有两种方法：

 　　方法一：用模块定义文件（.def）进行导出声明　　

// dllmain.cpp : 定义 DLL 应用程序的入口点。
#include "stdafx.h"

int dllGlobalVar;

BOOL APIENTRY DllMain( HMODULE hModule,
                       DWORD  ul_reason_for_call,
                       LPVOID lpReserved
                     )
{
    switch (ul_reason_for_call)
    {
    case DLL_PROCESS_ATTACH:
        dllGlobalVar = 123;
        break;
    case DLL_THREAD_ATTACH:
    case DLL_THREAD_DETACH:
    case DLL_PROCESS_DETACH:
        break;
    }
    return TRUE;
}



LIBRARY dllExportVariable_def
EXPORTS
dllGlobalVar DATA

　　特别要注意的是用extern int dllGlobalVar声明所导入的并不是DLL中全局变量本身，而是其地址，应用程序必须通过强制指针转换来使用DLL中的全局变量。这一点，从*(int*)dllGlobalVar可以看出。因此在采用这种方式引用DLL全局变量时，千万不要进行这样的赋值操作：

                dllGlobalVar = 1;
　　其结果是dllGlobalVar指针的内容发生变化，程序中以后再也引用不到DLL中的全局变量了。

　　而通过_declspec(dllimport)方式导入的就是DLL中全局变量本身而不再是其地址了，笔者建议在一切可能的情况下都使用这种方式。

　　方法二：用__declspec进行导出声明

__declspec(dllexport) extern int dllGlobalVar = 88;

   (2) 调用DLL中导出的变量：

　　同样，应用程序调用DLL中的变量也有两种方法。 

　　第一种是隐式链接： 

#include <iostream>
using namespace std;

#pragma comment(lib, "..\x64\Debug\dllExportVariable_declspec.lib")
extern _declspec(dllimport) int dllGlobalVar;

int main()
{
    cout << "dllGlobalVar = " << dllGlobalVar << endl;

    dllGlobalVar = 88;
    cout << "dllGlobalVar = " << dllGlobalVar << endl;

    getchar();
    return 0;
}

　　第二种是显式链接： 

#include <iostream>
using namespace std;

#include <windows.h>

int main()
{
    int my_int;
    HINSTANCE hInstLibrary = LoadLibrary(TEXT("dllExportVariable_def.dll"));

    if (hInstLibrary != NULL)
    {
        my_int = *(int*)GetProcAddress(hInstLibrary, "dllGlobalVar");
        cout << "my_int = " << my_int << endl;
    }
    FreeLibrary(hInstLibrary);

    getchar();
    return 0;
}

　　Note：一般不建议从DLL中导出全局变量，对于希望从DLL获取资源以实现资源共享的情景，最好是通过导出一个Get函数获得，这样操作起来更方便而且更安全。

7. DLL导出类

　　一、导出类的简单方式

　　　　这种方式是比较简单的，同时也是不建议采用的不合适方式。　

　　　　只需要在导出类加上__declspec(dllexport)，就可以实现导出类。对象空间还是在使用者的模块里，dll只提供类中的函数代码。

　　　　不足的地方是：使用者需要知道整个类的实现，包括基类、类中成员对象，也就是说所有跟导出类相关的东西，使用者都要知道。通过Dependency Walker可以看到，这时候的dll导出的是跟类相关的函数：如构造函数、赋值操作符、析构函数、其它函数，这些都是使用者可能会用到的函数。

　　　　这种导出类的方式，除了导出的东西太多、使用者对类的实现依赖太多之外，还有其它问题：必须保证使用同一种编译器。导出类的本质是导出类里的函数，因为语法上直接导出了类，没有对函数的调用方式、重命名进行设置，导致了产生的dll并不通用。

 

　　　　简单方式导出类的DLL示例：

#pragma once

//相关的类都必须导出
class _declspec(dllexport) CBase
{
public:
    void Test1();
private:
    int m_var1;
};

//相关的类都必须导出
class _declspec(dllexport) CData
{
public:
    void Test2();
private:
    int m_var2;
};

//要导出的类
class _declspec(dllexport) CExportClass : public CBase
{
public:
    CExportClass(int i = 0);

    void TestFun();
    CData GetDataObj() { return m_DataObj; }

private:
    int m_i;
    CData m_DataObj;
};

CExportClass::CExportClass(int i) : m_i(i)
{
}

void CExportClass::TestFun()
{
    cout << "This is TestFun() from CExportClass class!" << endl;
}

void CBase::Test1()
{
    cout << "This is Test1() from CBase class!" << endl;
}

void CData::Test2()
{
    cout << "This is Test2() from CData class!" << endl;
}

　　　调用示例：

#include "stdafx.h"
#include <Windows.h>
#include "..dllTest_ExportClass(NotRecommend)dllTest_ExportClass(NotRecommend).h"

#pragma comment(lib, "..\x64\Debug\dllTest_ExportClass(NotRecommend).lib")

int main()
{
    CExportClass obj(55);
    obj.Test1();
    obj.TestFun();

    CData DataObj = obj.GetDataObj();
    DataObj.Test2();

    system("pause");
    return 0;
}

 　　二、导出类的较好方式

　　　　这种方式和COM类似，它的结构是这样的：导出类是一个派生类，派生自一个抽象类(都是纯虚函数)。使用者只需知道这个抽象类的结构。

　　　　DLL最少需要提供一个用于获取类对象指针的接口。使用者和DLL提供者共用一个抽象类的头文件。使用者依赖于DLL的东西很少，只需要知道抽象类的接口，以及获取对象指针的导出函数，对象内存空间的申请是在DLL模块中做的，释放也在DLL模块中完成(需要在最后调用释放对象的函数)。

　　　　这种方式比较好，通用，产生的DLL没有特定的环境限制。除了对DLL导出类有好处外，它采用接口和实现分离，也可以使得工程结构更清晰，使用者只需要知道接口，不需要知道实现。

　　　　

　　　　测试示例代码下载地址：　https://files.cnblogs.com/files/YQ2014/dllTest_ExportClass%28NotRecommend%29.zip　　　

　　

　　参考资料：

　　http://www.cnblogs.com/cswuyg/archive/2011/10/06/DLL2.html

　　http://www.codeproject.com/KB/cpp/howto_export_cpp_classes.aspx

　　

　　导出类的DLL要小心DLL Hell问题。

       详细的可以参考：DLL导出类避免地狱问题的完美解决方案