【C++】封装 调用 dll / lib

笔记用，有错误欢迎指出，谢谢。

一、lib / dll 文件

静态库：在链接步骤中，连接器将库文件取得所需的代码，复制到生成的可执行文件中，这种库叫做静态库，其特点是可执行文件中包含了库代码的一份完整拷贝;缺点就是被多次使用就会有多份冗余拷贝。即静态库中的指令全部被直接包含在最终生成的exe文件中。在vs中新建生成静态库的工程，编译生成成功后，只产生一个.lib文件。

动态库：动态库链接是一个包含可由多个程序同时使用的代码和数据的库，DLL不是可执行的文件，动态库提供一种方法，使进程可以调用不属于其可执行代码的函数。函数的可执行代码位于一个DLL中，该DLL中包含一个或者多个已经被编译，链接并使用它们的进程分开存储的函数，在vs中新建生成动态库的工程，编译成功后，产生一个.lib和一个.dll文件。

静态库的lib：该lib包含函数的代码本身（包括函数的索引，也包括实现），在编译 的时候将代码加入程序当中

动态库的lib：该lib包含了函数所在的DLL文件和文件中函数位置的信息，函数实现代码由运行的时候加载在进程空间中DLL提供，总之，lib是编译的时候用到的，如果完成源代码的编译，只需要lib，如果要使得动态库的程序运行起来，只需要dll。

静态库.a(win下是lib) 和动态库.so(win下是.dll)，所谓静态，动态是指链接

两个文件详解参考连接：lib和dll的区别，生成以及使用详解_googler_offer的博客-CSDN博客_dll lib

二、封装和调用 lib/dll文件

1、lib 文件的封装和 dll 类似，在导出时选则即可。

2、打包生成 lib 文件时，只会生成 .lib（大小较大）文件。

调用 .lib，需要 .h + .lib；因为有头文件，调用时正常使用头文件中函数即可。

3、打包生成  dll 文件时，会生成 .lib（大小较小） 和 .dll 两个文件；

隐式调用 .dll，需要 .h + .lib + .dll。

显示调用 .dll，需要 .dll。

4、_declspec(dllexport) 关键字

修饰要导出给外部使用的函数。

5、extern "C"

按照c语言的函数地址风格。粗略理解：例如函数 func(int, int)，对于c语言编译后内部标识符名称为_func；对于c++，因为存在按照参数重载，编译后内部标识符为func_int_int。

此处参考：https://www.cnblogs.com/pingge/articles/3155289.html

所以对于给外部使用的函数要加 extern "C"，这样在显示调用时才能通过函数名正确找到函数地址。

在不使用 extern "C" 的情况下，也可使用 .def 文件，待补充。

三、相关例子

1、封装函数到dll中，显示调用

封装：函数的头文件如下，源文件中正常写相关定义即可：

#ifndef FUNCTEST_H
#define FUNCTEST_H

extern "C" void _declspec(dllexport) PrintStr();
extern "C" int _declspec(dllexport) GetNum();
extern "C" int _declspec(dllexport) CalNum(int x, int y);

#endif 

显示调用：

    typedef void(*printStr)();  //定义要获取的函数指针类型
    //显示调用 dll 中封装的函数
	HINSTANCE hdll;
	printStr pStr;
	hdll = LoadLibrary("DllFuncTest.dll");
	//hdll = LoadLibraryEx("DllFuncTest.dll", NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
	if (hdll == NULL) {
		FreeLibrary(hdll);
		cout << "hdll == NULL" << endl;
		return 0;
	}
	pStr = (printStr)GetProcAddress(hdll, "PrintStr");
	if (pStr == NULL) {
		FreeLibrary(hdll);
		cout << "pStr == NULL" << endl;
		return 0;
	}
	pStr();
	FreeLibrary(hdll);

2、封装类到dll中，隐式调用

封装：先写一个接口基类，然后实际工作类继承于基类，对外暴露基类的头文件，用基类的指针指向派生类来工作。

基类头文件：

#ifndef THTERFACE_H
#define THTERFACE_H
#define TEST_API __declspec(dllexport)

class TEST_API InterFace {
public:
	static InterFace* InitInterface();
	virtual void Init() = 0;
	virtual void GetName() = 0;
};
#endif 

派生类文件：

#include "InterFace.h"
#include 
#include 

using namespace std;

class Test : public InterFace {
public:
	Test();
	void Init();
	virtual void GetName();
private:
	string m_name;
	int m_num;
};

Test::Test() {
	cout << "派生类构造函数" << endl;
}

void Test::Init() {
	m_name = "nihao";
	m_num = 666;
}

void Test::GetName() {
	cout << m_name << '\t' << m_num << endl;
}

//这种写法有弊端：
//接口类里面必定定义了一个用于实际干活的派生类实例，
//只能用于 隐式调用dll
InterFace* InterFace::InitInterface() {
	return new Test();
}

隐式调用（.h + .lib + .dll）:

#include "DllTest/InterFace.h"
	
    InterFace* test = InterFace::InitInterface();
	test->Init();
	test->GetName();

3、显示调用dll中的类

封装：同样先确定一个接口基类，工作类继承于接口基类。不同的是需要增加一个全局函数供外部显示调用，该函数返回值类型 为基类的指针，实际返回了一个工作类的实例。

这种写法，固定一个接口基类即可。dll针对于已有的接口开发，不同工作的类在各自的文件中返回各自的实例即可。

接口基类如下：

#pragma once

class InterFaceClass {
public:
	virtual ~InterFaceClass() {};
	virtual void Init() = 0;
	virtual void func1() = 0;
};

实际工作类：

#pragma once
#include "InterFaceClass.h"
#include 

#define WORK_API __declspec(dllexport)

//这个地方的 __declspec(dllexport) 可写可不写，不影响外部使用
class WorkClass : public InterFaceClass
{

public:
	WorkClass();
	~WorkClass();
	void Init();
	void func1();
private:
	std::string m_name = "ni hao";
	int m_num = 0;

};

//这里要有 __declspec(dllexport) 的声明，不然外部无法找到该函数
//不写的话，写在 .def 文件里面也可以
extern "C" WORK_API InterFaceClass* GetIntance() {
	return new WorkClass();
};

#include "WorkClass.h"
#include 

using namespace std;

WorkClass::WorkClass() {
	cout << "WorkClass::WorkClass()" << endl;
}

WorkClass::~WorkClass() {
	cout << "~WorkClass::WorkClass()" << endl;
}

void WorkClass::Init() {
	cout << "WorkClass::Init()" << endl;
	m_name = "hahahah";
	m_num = 999;
}

void WorkClass::func1() {
	cout << "WorkClass::func1()" << endl;
	cout << m_name << '\t' << m_num << endl;
}

显示调用：

	HINSTANCE hdllClass;
	hdllClass = LoadLibrary("DllClassTest.dll");
	if (hdllClass == NULL) {
		FreeLibrary(hdllClass);
		cout << "hdllClass == NULL" << endl;
		return 0;
	}
	WorkInstance getWork;
	getWork = (WorkInstance)GetProcAddress(hdllClass, "GetIntance");
	if (getWork == NULL) {
		FreeLibrary(hdllClass);
		cout << "work == NULL" << endl;
		return 0;
	}
	InterFaceClass* work = getWork();
	work->func1();
	work->Init();
	work->func1();
	FreeLibrary(hdllClass);
	return 0;