动态库

考虑两个问题：

• 我们都知道printf函数只有在引用头文件include<stdio.h>才能使用，但当我们查看<stdio.h>时可以发现里面只有对printf的声明而没有对他的定义，对他的定义在哪
• 你发明一个有价值的算法，想让别人使用但又不想把核心代码公布

库Library

可以将编译好的符号提供给第三方使用，库分为动态库和静态库。

• 动态库 Dynamic-Link Library（DLL）
• 静态库 Static Library

用vc创建一个类型为dll的控制台项目，点dll，导出符号，取消安全开发生命周期检查，vc会自动创建dll的项目框架，它自动生成一个DllMain函数，就相当于main函数

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

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;
}

为了实现一个函数，定义在dll里面，外面看不到但是可以使用

就要把名字导出（export）

//在原项目新建mydll文件，拷贝进下列代码

//将Add函数export出去
__declspec(dllexport) int Add(int a,int b)
{
    return a+b;
}

DLL项目设置

项目创建好后，在项目属性设置中配置属性，常规，输出目录$(SolutionDir)，目标文件名my

• 取消预编译头文件
• 代码生成改为/MTd编译
• 编译生成my.lib和my.dll

my.dll：包含所有代码编译成的指令

my.lib：包含一个列表，表明my.dll中含有哪些符号、每个符号对应在dll中的位置（被导出的符号）

故lib文件比dll文件要小

这时动态库已经好了，新建一个项目App来使用它

///main.cpp
#include<stdio.h>
//使用库
#pragma comment(lib,"my.lib")
//声明：此函数需要从dll导入，将my.dll和my.lib放在App项目的根目录里，这样App才知道my.lib是什么东西。
__declspec(dllimport) int Add (int a,int b);

int main()
{
    int result = Add(1,2);
    printf("%d\n",result);
    return 0;
}

通过使用DLL技术，既隐藏了代码，又公开了功能

运行App程序时，my.dll会被操作系统加载，放在指定位置才能被找到，直接运行App.exe是不行的

DLL放在以下位置可以被操作系统找到

• 可执行文件所在目录：项目根目录\Debug
• 进程当前目录：项目根目录
• 系统目录，如C:\Windows\System32和C:\Windows\System
• Windows目录，如C:\Windows
• 环境变量PATH中的目录

DLL的加载与卸载

DLL不能独立运行，只有exe文件被运行时，dll才会被加载运行

在exe文件中有一些标识信息，表示该exe依赖哪些dll文件，操作系统据此去寻找加载相应的dll文件

exe被加载到内存，形成一个进程process，dll也被加载到内存

进程可以直接调用dll

在dll文件中，至少分为两个段

• 数据段Data Section存放全局变量
• 代码段Code Section存储指令，函数

当dll被加载时，代码段只被加载一次，是公共的。数据段被每个程序各自拷贝一份，是私有的。

///DLL项目mydll.cpp
#include<stdio.h>
static int value = 0;
#define MYDLL __declspec(dllexport)

MYDLL int MyGet()
{
    return value;
}

MYDLL void MySet(int n)
{
    value = n;
}
///App项目maim.cpp
#include<stdio.h>
//使用库
#pragma comment(lib,"my.lib")
#define MYDLL __declspec(dllexport)
//声明：此函数需要从dll导入
MYDLL int MyGet ();
MYDLL void MySet(int n);

int main()
{
    int value = MyGet();
    printf("%d\n",value);

    MySet(value+1);
    value = MyGet();
    printf("%d\n",value);
    //输入回车窗口关闭
    getchar();
    return 0;
}

启动main.cpp显示0，1。

符合预期，保持窗口在启动main.cpp，结果还是0，1。这时有两个窗口，常识里本应该第二个窗口是1，2，但结果还是0，1。说明这两个进程是没有影响的。这两个窗口中变量地址是相同的，为什么地址相同进行修改，值仍然不变呢，因为这个变量存在虚拟地址里。

当dll文件被加载后，不能修改或者删除，直到进程把他卸载才行

• 同一个进程里面，两个变量地址相同，那他肯定是同一个变量
• 不同的进程里，变量地址可以相同，但不是同一个变量，因为是存在虚拟内存里面

DLL的动态内存管理

在dll中malloc的内存，必须在dll中free

///DLL项目mydll.cpp
#include <stdio.h>
#include <stdlib.h>

#define MYDLL __declspec(dllexport) 

MYDLL int* MyAlloc(int size)
{
    int* p = (int*) malloc(size*sizeof(int));

    for(int i=0; i<size; i++)
    {
        p[i] = i;
    }
    return p;
}

MYDLL void MyFree(int* p)
{
    free(p);
}

///App项目main.cpp
#include <stdio.h>
#include <stdlib.h>

// 使用库
#pragma comment(lib, "my.lib")

#define MYDLL __declspec(dllimport) 
MYDLL int* MyAlloc(int size);
MYDLL void MyFree(int* p);

int main()
{
    int* p = MyAlloc(4);
    for(int i=0; i<4; i++)
    {
        printf("%d \n", p[i]);
    }

    //free(p);   错误！！！只能在dll中free
    MyFree(p);  //使用dll的函数free
    
    return 0;
}

使用头文件

在创建DLL时，应该附带一份头文件，而不是让使用者自己去写函数声明。头文件需用到条件编译指令

///DLL项目mydll.cpp
#include <stdio.h>

#define MYDLL_EXPORTS        
//定义了MYDLL_EXPORTS，说明MYDLL为__declspec(dllexport)
#include "mydll.h"

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

///DLL项目mydll.h，需用到条件编译指令
#ifndef _MYDLL_H
#define _MYDLL_H

#ifdef MYDLL_EXPORTS    
//若cpp文件定义了MYDLL_EXPORTS，则定义MYDLL为__declspec(dllexport)
#define MYDLL __declspec(dllexport) 
#else
#define MYDLL __declspec(dllimport) 
#endif

MYDLL int Add(int a, int b);

#endif

///将mydll.h，my.dll，my.lib拷贝到项目App根目录
///App项目main.cpp
#include <stdio.h>
#include "mydll.h"
// 使用库
#pragma comment(lib, "my.lib")

int main()
{
    int result = Add(1,2);
    printf("%d\n",result);

    return 0;
}

部署到指定位置

D:/SDK/mydll/bin/存放dll文件和bin文件

D:/SDK/mydll/include/存放.h文件

项目->属性，在包含文件->添加include文件夹，在库文件添加bin文件夹

这样#include<mydll.h>就可以直接用尖括号了，双引号""优先从根目录找，找不到再去系统目录找

此时App项目下面的dll，lib，.h就不再需要了，因为它所需的文件都被我们放在系统文件里面去了。将dll文件放在任意系统目录即可，如c盘windows32。

导出类

在dll中导出类的定义，其实就是导出其成员函数。

///在DLL项目下新建MyObject.h和MyObject.h
///MyObject.h
#ifndef _MY_OBJECT_H
#define _MY_OBJECT_H

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

class MYDLL MyObject
{
public:
    MyObject(int v);
    void Print();

private:
    int value;
};

#endif

///MyObject.cpp
#include <stdio.h>

#define MYDLL_EXPORTS
#include "MyObject.h"

MyObject::MyObject(int v)
    :value(v)
{

}

void MyObject::Print()
{
    printf("value: %d \n", value);
}

///App项目的main函数
#include <stdio.h>
#include "MyObject.h"

// 使用库
#pragma comment(lib, "my.lib")

int main()
{
    MyObject obj(2);
    obj.Print();
    return 0;
}

静态库

static library

仅生成一个.lib文件，静态库中直接就有代码段和数据段，只是打个大包而已，在链接过程中，是直接把里面的东西链接过来，形成完整的可执行程序。exe运行时不依赖lib文件。

///新建静态库工程，新建mylib.h
#ifndef _MYLIB_H
#define _MYLIB_H

int Add(int a, int b);


#endif

///新建mylib.cpp
#include "mylib.h"

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

//新建App项目，main函数
#include <stdio.h>
#include "mylib.h"
#pragma comment(lib,"my.lib")

int main()
{
    int result = Add(1,2);
    printf("%d\n",result);
    return 0;
}

静态库的使用不方便，如果你的静态库是vs2008编译的，那么别人的App文件也必须使用vs2008编译，版本必须一样。 而且代码生成的选项也必须一样，比如都要是/MTd

唯一优点：exe运行时不依赖lib文件。

dll文件要更改的时候可以直接把文件替换过去， 而静态库要更改还要重新编译

动态库的手工加载

自动加载：在编译时指定dll，当exe文件启动时会首先加载相关的dll

手工加载：在编译时不指定dll，在运行的时候调用LoadLibrary来加载

使用LoadLibrary加载dll

使用FreeLibrary卸载dll

增加灵活性，但更复杂了。

dll里面每个函数或全局变量都叫一个symbol，int Add(int a,int b)函数

• 在“C”下面叫：_Add
• 在“C++”下面包括函数名和参数列表，叫：_Add_int_int

///mydll.h
#ifndef _MYDLL_H
#define _MYDLL_H

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

extern "C" MYDLL int Add(int a, int b);  //将函数声明为C的函数

#endif

然后将dll文件放在根目录就行，手工方式不需要将lib文件和头文件拷贝

///App项目的main函数
#include <stdio.h>
//包含windows的头文件
#include <winsock2.h>
#include <windows.h>

int main()
{
    HINSTANCE handle = LoadLibrary("my.dll");
    if(handle)
    {
        //定义要找的函数原型，即定义函数指针的类型
        typedef int (*DLL_FUNCTION_ADD) (int, int);
        //左边的int为函数返回值，右边为参数列表
        //找到目标函数的地址
        DLL_FUNCTION_ADD dll_func = (DLL_FUNCTION_ADD)GetProcAddress(handle, "Add");
        if(dll_func)
        {
            //调用该函数
            int result = dll_func(10, 11);
            printf("result: %d \n", result);
        }
        //卸载
        FreeLibrary(handle);
    }
    return 0;
}

在App项目，项目，属性，常规，字符集使用多字节才行。

优点：在需要的时候才加载，用完了就卸载

只需要dll文件，不需要lib和h文件

VC项目的静态编译

自己的hello.exe（里面有printf）给别人却用不了。

默认你的exe是动态编译的，即需要动态库，但是别人的机器上没有那个dll，所以无法运行。

printf的库实际上在c:/Program Files/Miscrosoft Visual Studio 13.0/VC/lib里面的libcmt.lib，别人没有安装vs当然没有这个库

静态编译：/MTd、/MT ，小写d表示debug，表示是否允许调试，M表示是否多线程，T表示text代码，D表示Dynamic，动态

动态编译：/MDd、/MD

把代码生成的那个选项改为MTd就行了，然后点重新生成解决方案，ctrl alt f7