C++学习笔记——动态库与静态库

最新推荐文章于 2024-08-09 19:33:02 发布

小天狼星不来客

最新推荐文章于 2024-08-09 19:33:02 发布

阅读量2k

点赞数

分类专栏： C++ 文章标签： C dll lib

本文链接：https://blog.csdn.net/ColdWindHA/article/details/82019290

版权

C++ 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

0. 库技术简介

1. DLL用例示范

2. DLL的加载、卸载与多进程的数据段

3. DLL中的动态内存分配

4.为DLL添加头文件

5.在DLL中导出一个类

6. 静态库的编译

7. 动态库的手工加载

8. VC项目的静态编译

0. 库技术简介

在C/C++中可以将一种编译好的符号提供给第三方来使用，而源码是对用户不可见的，就是“库技术”。简单的来说就是“公开了技术，隐藏了代码”。库技术分为两种：动态库（Dynamic-Link Library, DLL）和静态库（Static Library）。

1. DLL用例示范

1> 创建一个简单的.dll程序

VS2015新建项目——windows控制台程序——点击dll创建完成。生成的项目中自动包含了两个头文件和三个cpp文件。

stdafx.h
targetver.h

dllmain.cpp
LibraryExercise.cpp //工程名
stdafx.cpp

检查三个cpp文件，发现dllmain.cpp中的dllMain作为项目的dll主函数，是系统运行最先进入的函数；stdafx.cpp与预编译信息有关；我们需要导出的核心算法在LibraryExercise.cpp中实现。打开LibraryExercise.cpp文件，输入以下代码：

// LibraryExercise.cpp : 定义 DLL 应用程序的导出函数。

#include "stdafx.h"

_declspec(dllexport) int add(int a, int b)
{
	return a + b;
}

需要注意的是，如果需要导出一个全局函数，就需要在其前用关键字来声明：_declspec(dllexport)，这是一个windows的函数，在Linux平台下不可用。最后还需要在项目属性中设置以下三个步骤：

取消“预编译头文件”:配置属性——C/C++——预编译头——创建/使用预编译头——不适用预编译头。改为/Mtd编译：配置属性——C/C++——代码生成——运行时库——多线程调试（/Mtd）。修改输出的dll名字：配置属性——链接器——输出文件 ——改为Add.dll。

编译后即可在当前目录下找到Add.dll以及Add.lib文件。下面解释Add.dll和Add.lib的区别：

.dll文件包含所有编译出的二进制指令

.lib文件包含一个列表，表明相对应的.dll文件中有哪些符号，每个符号对应在dll中的位置。

因此dll文件要比lib文件大得多。

2> 在应用程序中使用动态库

在新创建的项目中创建main.cpp，并在其中添加如下代码：

#include <stdio.h>

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

//声明:此函数需从dll导入
_declspec(dllimport) int Add(int a, int b;)

int main(int argc, char** argv)
{
    int result = Add(2, 3);
    printf("Result is %d \n", result);
    return 1;
}

同时将Add.dll和Add.lib放在规定目录下，否则找不到。强调：导入和导出分别使用命令：_declspec(dllimport)和_declspec(dllexport)，需加以区分。dll文件需放在以下五个目录中的任意一个即可被操作系统找到：

可执行文件所在目录；
进程当前目录；
系统目录，如C:\Windows\System32等；
Windows目录，如C:\Windows;
环境变量（系统变量）PATH中的目录。（注：环境变量修改后重启生效！）

2. DLL的加载、卸载与多进程的数据段

需要明确的是，dll文件并不能独立运行，只有当可执行文件.exe加载它时，他才能运行。在exe中有一些标志性信息，表明了此exe文件需要依赖那些dll文件，操作系统即在上述五个目录开始寻找dll文件。exe被加载到内存，形成一个进程(process)，dll也被加载到内存；此时进程可以直接调用dll里的函数。因此一个可执行文件实体可以有多个进程，那么我们就来考虑一个问题，当多个进程同时调用一个dll时，dll的全局数据段是共享的吗？考虑一下代码：

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

static int value = 0;

_declspec(dllexport) void ValueSet(int a)
{
    value = a;
}

_declspec(dlliexport) int ValueGet()
{
    return value;
}

//import.cpp

#include<stdio.h>
#pragma comment(lib, "my.lib")

_declspec(dllimport) int ValueGet();
_declspec(dllimport) void ValueGet(int a);

int main()
{
    int a = ValueGet();
    printf("Value : %d", a);

    ValueSet(120);
    int a = ValueGet();
    printf("Value : %d", a);
    printf("&Value : %f", &Value);
    getchar();
    return 1;
}

从上述代码可以看出，value作为dll中的一个静态全局变量，在第一次运行import.exe退出进程前值被置为120，那么问题在于，当地一个进程不退出，再次运行import.exe时，输出的value是0还是120呢？答案是0！这说明一个问题：进程之间调用dll并没有影响。原因在于当dll被加载时，代码段被加载一次，是公共的；而数据段各自程序拷贝一次，是私有的。

注意事项：

当有exe运行时，dll被加载，文件处于被占用状态，不能删除，移动，直到它被卸载。
当所有进程都退出时，dll被卸载。
不同进程之间不能比较dll中的变量的地址，如上import.cpp中每次运行第三个printf输出结果都是相同的。（虽然数据段是私有的，但是地址却是相同的，原因在于采用了虚拟地址）

3. DLL中的动态内存分配

在dll中的malloc的内存，必须在dll中free。（这是由windows决定的）可看以下实例：

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

#define MYDLL _declspec(export)

MYDLL int* MyAlloc(int size)
{
    int* p = malloc(size * sizeof(int));
    
    for(int i = 0; i < size; i++)
    {
        p[i] = i;
    }
    return p;
}

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

//import.cpp
#include <stdio.h>
#include <stdlib.h>

#pragma comment(lib, "my.lib")
#define MyDLL _declspec(import)
MyDLL int* MyAlloc(int size);
MyDLL void MyFree(int* p);

int main(int argc, char** argv)
{
    int* p = MyAlloc(4);
    
    free(p);     //在dll内分配的动态内存在dll外释放会报错
    return 1;
}

正确的做法应该是将free(p)改成MyFree(p).

4.为DLL添加头文件

如果用户利用以上方法对dll中的函数进行声明，不仅给用户带来很多麻烦，而且用户要对dll中有哪些函数非常清楚，这显然是不可能做到的，因此按照惯例，应由模块的作者提供头文件，头文件中应有类型和函数声明。

1> 为DLL创建头文件

//mydll.h
//这个.h文件在编译生成APP的项目和用户实际使用的项目中是通用的，其起作用的方式是条件编译。

#ifndef _MYDLL_H_
#define _MTDLL_H_

#ifdef MYDLL_EXPORT
#define MYDLL _declspec(dllexport)    //在编译dll工程的.cpp文件里，定义宏MYDLL_EXPORT
#else
#define MYDLL _declspec(dllimport)    //在用户工程的.cpp文件里，什么都不用定义就行了
#endif

#include <stdio.h>
MYDLL int Add (int a, int b);

#endif

//mydll.cpp
#define MYDLL_EXPORT                    //预编译规定“输出选项”，用作编译dll工程里的cpp文件
#include <mydll.h>

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

生成dll、lib文件后，将dll、lib和h文件一并拷贝至目标工程文件夹，目标工程cpp调用dll文件中函数如下，用户根据头文件即可知道dll中函数的相关信息，同时也省去了导入函数的麻烦。

#include <stdio.h>
#include <mydll.h>                    
//此处不需任何其他宏定义，h文件中MYDLL自动被编译为_declspec(import)

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

int main(int argc, char** argv)
{
    int result = Add(10, 11);
    printf("Result : %d", result);
    return 1;
}

2> DLL相关文件的部署

可将dll的相关文件部署到指定文件夹，并将头文件作为系统文件导入。创建mydll文件夹，包含子文件夹include与bin，其中include存放头文件，bin里存放dll与lib文件。这样就可以用尖括号包含了。

#include <mydll.h>        //C++中尖括号表示系统文件，双引号表示用户自己的头文件

3> 用户DLL的配置

与OpenCV的配置相似，在VC++目录中配置包含目录——添加include，库目录——添加bin，同时将dll文件部署到系统能找到的5个目录之一即可（OpenCV的选项是添加到环境变量中）。

5.在DLL中导出一个类

导出类的定义，实际上就是导出类的成员函数，关于h文件等操作与导出普通函数极为相似，只需注重语法上的问题。

//myClassDll.h         在此文件中保存类的定义

#ifndef _MY_CLASS_DLL_H
#define _MY_CLASS_DLL_H

#ifdef MYDLL_EXPORT
#define MYDLL _declspec(dllexport)
#else
#define MYDLL _declspec(dllimport)
#endif

class MYDLL MyObj        //整个类的导出和导入只需此处用到MYDLL
{
public:
    MyObj(int v);
    void display();

private:
    int value;   
}

#endif

//myClassDll.cpp
#include <stdio.h>
#define MYDLL_EXPORT
#include "myClassDll.h"

//在cpp中定义的成员函数无需再使用关键字MYDLL导出
MyObj:: MyObj(int v)
:value(v)
{
}

void MyObj:: diplay()
{
    printf("Value: %d", value);
}


//Target.cpp 目标工程cpp
//包含头文件和lib后直接实用类创建对象
#include <stdio.h>
#include "myClassDll.h"

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

int main(int argc, char** argv)
{
    MyObj object(123);
    object.display();
    
    return 1;
}

6. 静态库的编译

静态库相比于动态库而言要简单得多，没有动态库的导入和导出操作，其优缺点、适用范围等也与动态库有着很多不同。首先我们看一下静态库的实质：静态库仅有一个.lib文件，其中直接含有代码段和数据段，在连接过程中，相当于直接把代码和数据替换过来，形成完整的可执行程序，因而最终生成的.exe文件是对.lib文件没有依赖的，从体积上看，静态库lib的大小要比动态库的lib大得多。

1> 编写一个静态库文件并调用

// mylib.h 静态库h文件
#ifndef _MYLIB_H_
#define _MYLIB_H_

int Add(int a, int b);

#endif

//mylib.cpp 静态库cpp文件
#include "mylib.h"

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

从上述代码段来看，静态库文件的编写和普通h和cpp文件的编写并无差别。在配置属性——连接器——输出中可设定编译后lib文件的名称和位置，注意同dll文件一样，需要在配置属性——C/C++——预处理器中取消预编译头。

2> 调用一个静态库文件

将编译生成的lib文件同h文件一并拷贝至目标工程文件夹下，创建APP.cpp并输入以下代码，完成对库的调用。

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

#include "mylib.h"
#pragma comment(lib, "mylib")

int main(int argc, char** argv)
{
    int result = Add(10, 11);
    printf("Result : %d", result);
    return 1;
}

3> 静态库的几点说明

对静态库的使用有所限制，某一版本VS编译的静态库文件只能供同一版本VS的工程调用；编译静态库的工程与调用静态库的工程以下属性必须相同：配置属性——C/C++——代码生成——运行时库（要是Mtd都是Mtd等等），否则会出现LINK Warning LNK4098。
静态库的优点：使用静态库生成的exe文件不再依赖于lib文件。
DLL的优点: 便于升级更新，只要接口保持不变，可直接替换DLL来升级程序，并不需要重新编译程序。

7. 动态库的手工加载

在上述加载DLL的过程中，exe文件在开始运行时首先加载所有用到的dll文件，再运行，被称为动态库的自动加载。也可以在编译时不指定dll，在运行时调用LoadLibrary来加载动态库，使用FreeLibrary来卸载动态库，这种方式被称为手动加载，它提供了一种在运行时、手工加载dll的技术手段，增加了编程的灵活性。

1> 手工加载示例

对DLL的3要求：

要求待调用函数按照“C”方式编译
dll文件可被系统搜索到

//mydll.h 

#ifndef _MYDLL_H_
#define _MYDLL_H_

#include <stdio.h>

#ifdef MYDLL_EXPORT
#define MYDLL _declspec(dllexport)
#else
#define MYDLL _declspec(dllimport)
#endif

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

#endif

//mydll.cpp

#include "mydll.h"

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

2> 关于extern "C"的说明

首先需要弄明白C函数与C++函数的区别。在存储时，函数和变量一样，都占有一定的内存空间，而函数名被加以修饰后，可作为函数内存空间的首地址，联想类比数组。C++函数的一个重要特性在于函数的可重载性，一般C函数的修饰的是固定的，例如int Add(int a, int b)函数，可能存储时首地址名为_Add，而C++由于重载的特性，存储时更为负载，有可能是将形参都列入函数名，如_Add_int_int等（这里只是举个例子，具体情况是编译器而定）。而extern “C”的作用是让编译器以C函数的方式编译目标函数，从而实现后期能够找到dll函数地址。

3> 手动加载方式

将dll文件放在系统可循的目录下后，在主程序中按如下代码手动加载dll

#include <stdio.h>

//包含windows相关头文件
#include <winsock2.h>
#include <windows.h>

int main(int argc, char** argv)
{

    HINSTANCE handle = LoadLibrary("my.dll");
    if(handle) //如果动态库加载成功
    {
        //定义要找的函数原型，用函数指针的形式
        typedef int (*DLL_FUNCTION_ADD) (int, int);      DLL_FUNCTION_ADD为关键字，括号必须有
        
        //找到目标函数地址
        DLL_FUNCTION_ADD dll_func = (DLL_FUNCTION_ADD)GetProcAddress(handle, "Add");
        if(dll_func)
        {
            //调用该函数
            int result = dll_func(10,20);
            printf("Result : %d", result);
        }
    }
    
    FreeLibrary(handle);
}