http://www.isotton.com/howtos/C++-dlopen-mini-HOWTO/
https://nullget.sourceforge.io/html/c/lcplugin.htm
https://my.oschina.net/u/1450061?tab=newest&catalogId=453169
https://www.cnblogs.com/my_life/articles/9493081.html
你定义好接口 Person 后，你并不知道谁将会实现该接口，甚至不知道什么时候会实现它。所以此时你无法通过 new 操作符来实例化对象。【这就是插件，接口的框架】
https://my.oschina.net/u/1450061/blog/204608
术语
dlopen API
关于dlclose、dlerror、dlopen和dlsym函数的描述可以在 dlopen(3) man手册页查到。
请注意，我们使用“dlopen”时，指的是dlopen函数，而使用“dlopen API”则是指整个API集合。
问题所在
有时你想在运行时加载一个库（并使用其中的函数），这在你为你的程序写一些插件或模块架构的时候经常发生。
在C语言中，加载一个库轻而易举（调用dlopen、dlsym和dlclose就够了），但对C++来说，情况稍微复杂。
动态加载一个C++库的困难一部分是因为C++的name mangling（译者注：也有人把它翻译为“名字毁坏”，我觉得还是不翻译好），另一部分是因为dlopen API是用C语言实现的，因而没有提供一个合适的方式来装载类。
在解释如何装载C++库之前，最好再详细了解一下name mangling。我推荐您了解一下它，即使您对它不感兴趣。因为这有助于您理解问题是如何产生的，如何才能解决它们。
Name Mangling
在每个C++程序（或库、目标文件）中，所有非静态（non-static）函数在二进制文件中都是以“符号（symbol）”形式出现的。这些符号都是唯一的字符串，从而把各个函数在程序、库、目标文件中区分开来。
在C中，符号名正是函数名：strcpy函数的符号名就是“strcpy”，等等。这可能是因为两个非静态函数的名字一定各不相同的缘故。
而C++允许重载（不同的函数有相同的名字但不同的参数），并且有很多C所没有的特性──比如类、成员函数、异常说明──几乎不可能直接用函数名作符号名。为了解决这个问题，C++采用了所谓的name mangling。它把函数名和一些信息（如参数数量和大小）杂糅在一起，改造成奇形怪状，只有编译器才懂的符号名。例如，被mangle后的foo可能看起来像foo@4%6^，或者，符号名里头甚至不包括“foo”。
其中一个问题是，C++标准（目前是[ISO14882]）并没有定义名字必须如何被mangle，所以每个编译器都按自己的方式来进行name mangling。
有些编译器甚至在不同版本间更换mangling算法（尤其是g++ 2.x和3.x）。即使您搞清楚了您的编译器到底怎么进行mangling的，从而可以用dlsym调用函数了，但可能仅仅限于您手头的这个编译器而已，而无法在下一版编译器下工作。
类
使用dlopen API的另一个问题是，它只支持加载函数。但在C++中，您可能要用到库中的一个类，而这需要创建该类的一个实例，这不容易做到。
解决方案
extern "C"
C++有个特定的关键字用来声明采用C binding的函数：extern "C" 。 用 extern "C"声明的函数将使用函数名作符号名，就像C函数一样。
因此，只有非成员函数才能被声明为extern "C"，并且不能被重载。尽管限制多多，extern "C"函数还是非常有用，因为它们可以象C函数一样被dlopen动态加载。
冠以extern "C"限定符后，并不意味着函数中无法使用C++代码了，相反，它仍然是一个完全的C++函数，可以使用任何C++特性和各种类型的参数。
加载函数
在C++中，函数用dlsym加载，就像C中一样。不过，该函数要用extern "C"限定符声明以防止其符号名被mangle。
示例1.加载函数
代码:
//----------
//main.cpp:
//----------
#include <iostream>
#include <dlfcn.h>
int main() {
using std::cout;
using std::cerr;
cout << "C++ dlopen demo\n\n";
// open the library
cout << "Opening hello.so...\n";
void* handle = dlopen("./hello.so", RTLD_LAZY);
if (!handle) {
cerr << "Cannot open library: " << dlerror() << '\n';
return 1;
}
// load the symbol
cout << "Loading symbol hello...\n";
typedef void (*hello_t)();
// reset errors
dlerror();
hello_t hello = (hello_t) dlsym(handle, "hello");
const char *dlsym_error = dlerror();
if (dlsym_error) {
cerr << "Cannot load symbol 'hello': " << dlsym_error <<
'\n';
dlclose(handle);
return 1;
}
// use it to do the calculation
cout << "Calling hello...\n";
hello();
// close the library
cout << "Closing library...\n";
dlclose(handle);
}
//----------
// hello.cpp:
//----------
#include <iostream>
extern "C" void hello() {
std::cout << "hello" << '\n';
}
在hello.cpp中函数hello被定义为extern "C"。它在main.cpp中被dlsym调用。函数必须以extern "C"限定，否则我们无从知晓其符号名。
警告：
extern "C"的声明形式有两种：上面示例中使用的那种内联（inline, 跟定义放在一起）形式extern "C" ， 还有才用花括号的extern "C" { ... }这种。
第一种内联形式声明包含两层意义：外部链接(extern linkage)和C语言链接(language linkage)，而第二种仅影响语言链接。
下面两种声明形式等价：
代码:
extern "C" int foo; // 外部链接 + c语言风格
extern "C" void bar();
和
代码:
extern "C" { //c 语言风格
extern int foo; //外部链接
extern void bar();
}
对于函数来说，extern和non-extern的函数声明没有区别，但对于变量就有不同了。如果您声明变量，请牢记：
代码:
extern "C" int foo;
和
代码:
extern "C" {
int foo;
}
是不同的物事(译者注：简言之，前者是个声明; 而后者不仅是声明，也可以是定义)。
进一步的解释请参考[ISO14882],7.5, 特别注意第7段; 或者参考[STR2000]，9.2.4。在用extern的变量寻幽访胜之前，请细读“其他”一节中罗列的文档。
加载类
加载类有点困难，因为我们需要类的一个实例，而不仅仅是一个函数指针。我们无法通过new来创建类的实例，因为类不是在可执行文件中定义的【类的定义在外部的动态库中】，况且（有时候）我们连它的名字都不知道。
解决方案是：利用多态性！ 我们在可执行文件【】中定义一个带虚成员函数的接口基类，而在模块中【动态库】定义派生实现类。通常来说，接口类是抽象的（如果一个类含有虚函数，那它就是抽象的）。
因为动态加载类往往用于实现插件，这意味着必须提供一个清晰定义的接口──我们将定义一个接口类和派生实现类。
接下来，在模块中，我们会定义两个附加的helper函数，就是众所周知的“类工厂函数（class factory functions）（译者注：或称对象工厂函数）”。
其中一个函数创建一个类实例，并返回其指针;
另一个函数则用以销毁该指针。这两个函数都以extern "C"来限定修饰。
为了使用模块中的类，我们用dlsym像示例1中加载hello函数那样加载这两个函数，然后我们就可以随心所欲地创建和销毁实例了。
示例2.加载类
我们用一个一般性的多边形类作为接口，而继承它的三角形类（译者注：正三角形类）作为实现。
代码:
//----------
//main.cpp:
//----------
#include "polygon.hpp"
#include <iostream>
#include <dlfcn.h>
int main() {
using std::cout;
using std::cerr;
// load the triangle library
void* triangle = dlopen("./triangle.so", RTLD_LAZY);
if (!triangle) {
cerr << "Cannot load library: " << dlerror() << '\n';
return 1;
}
// reset errors
dlerror();
// load the symbols
create_t* create_triangle = (create_t*) dlsym(triangle, "create");
const char* dlsym_error = dlerror();
if (dlsym_error) {
cerr << "Cannot load symbol create: " << dlsym_error << '\n';
return 1;
}
destroy_t* destroy_triangle = (destroy_t*) dlsym(triangle, "destroy");
dlsym_error = dlerror();
if (dlsym_error) {
cerr << "Cannot load symbol destroy: " << dlsym_error << '\n';
return 1;
}
// create an instance of the class
polygon* poly = create_triangle();
// use the class
poly->set_side_length(7);
cout << "The area is: " << poly->area() << '\n';
// destroy the class
destroy_triangle(poly);
// unload the triangle library
dlclose(triangle);
}
//----------
//polygon.hpp:
//----------
#ifndef POLYGON_HPP
#define POLYGON_HPP
class polygon {
protected:
double side_length_;
public:
polygon()
: side_length_(0) {}
virtual ~polygon() {}
void set_side_length(double side_length) {
side_length_ = side_length;
}
virtual double area() const = 0;
};
// the types of the class factories
typedef polygon* create_t();
typedef void destroy_t(polygon*);
#endif
//----------
//triangle.cpp:
//----------
#include "polygon.hpp"
#include <cmath>
class triangle : public polygon {
public:
virtual double area() const {
return side_length_ * side_length_ * sqrt(3) / 2;
}
};
// the class factories
extern "C" polygon* create() { //既是extern的，又是C的
return new triangle;
}
extern "C" void destroy(polygon* p) {
delete p;
}
加载类时有一些值得注意的地方：
◆ 你必须（译者注：在模块或者说共享库中）同时提供一个创造函数和一个销毁函数，且不能在执行文件内部使用delete来销毁实例，只能把实例指针传递给模块的销毁函数处理。
这是因为C++里头，new操作符可以被重载;这容易导致new-delete的不匹配调用，造成莫名其妙的内存泄漏和段错误。这在用不同的标准库链接模块和可执行文件时也一样。
◆ 接口类的析构函数在任何情况下都必须是虚函数（virtual）。因为即使出错的可能极小，近乎杞人忧天了，但仍旧不值得去冒险，反正额外的开销微不足道。
如果基类不需要析构函数，定义一个空的（但必须虚的）析构函数吧，否则你迟早要遇到问题，我向您保证。你可以在comp.lang.c++ FAQ( http://www.parashift.com/c++-faq-lite/ )的第20节了解到更多关于该问题的信息。
源代码
你可以下载所有包含在本文档中的代码包： http://www.isotton.com/howtos/C++-dl...xamples.tar.gz
FAQ
(译者注：下文翻译暂时省略)
1.I'm using Windows and I can't find the dlfcn.h header file! What's the problem?
The problem is that Windows doesn't have the dlopen API, and thus there is no dlfcn.h header. There is a similar API around the LoadLibrary function, and most of what is written here applies to it, too. Please refer to the Microsoft Developer Network Website for more information.
2.Is there some kind of dlopen-compatible wrapper for the Windows LoadLibrary API?
I don't know of any, and I don't think there'll ever be one supporting all of dlopen's options.
There are alternatives though: libtltdl (a part of libtool), which wraps a variety of different dynamic loading APIs, among others dlopen and LoadLibrary. Another one is the Dynamic Module Loading functionality of GLib. You can use one of these to ensure better possible cross-platform compatibility. I've never used any of them, so I can't tell you how stable they are and whether they really work.
You should also read section 4, “Dynamically Loaded (DL) Libraries”, of the Program Library HOWTO for more techniques to load libraries and create classes independently of your platform.
其他
* The dlopen(3) man page. It explains the purpose and the use of the dlopen API.
* The article Dynamic Class Loading for C++ on Linux by James Norton published on the Linux Journal.
* Your favorite C++ reference about extern "C", inheritance, virtual functions, new and delete. I recommend [STR2000].
* [ISO14882]
* The Program Library HOWTO, which tells you most things you'll ever need about static, shared and dynamically loaded libraries and how to create them. Highly recommended.
* The Linux GCC HOWTO to learn more about how to create libraries with GCC.
linux下C++ 插件(plugin)实现技术- -
（使用的特殊宏，对编译器的预处理器的使用 ,预处理器对##的处理）
应用程序中使用插件技术，有利于日后的版本更新、维护（比如打补丁）和功能扩展，是一种很实用的技术。其最大的特点是更新插件时无需重新编译主程序，对于一个设计良好的应用系统而言，甚至可以做到业务功能的在线升级。本文介绍了linux下用C++实现插件的一个简单实例，希望能对大家有所启发。
为了能做到更新插件时无需重新编译主程序，要求主程序中定义的接口是定死的，而接口的实现被放到了具体的插件中，这样主程序在运行时刻将插件加载进来，就可以使用这些接口所提供的功能了。在面向对象的系统中，各个功能模块被封装到类中，因此在C++中实现插件技术，就需要在主程序中提供基类，并为这些基类定义明确的接口，然后在插件（动态库或共享库）中定义派生类，并实现基类中所有的接口。
我们以计算多边形面积为例，首先定义一个基类CPolygon：
/*+********************************************************/
/* polygon.h */
#ifndef __POLYGON_H__
#define __POLYGON_H__
class CPolygon
{
public:
CPolygon(){}
virtual ~CPolygon(){}
virtual double area(void) const = 0;
};
#endif /* __POLYGON_H__ */
/*-********************************************************/
注意基类不一定是虚类（有纯虚函数的类），但是接口一定要定义成虚函数，因为最终主程序是通过基类指针来调派生类的接口函数，另外如果基类中有资源分配（new）的话，析构函数一定要定义成虚的，否则不会被调用，造成内存泄漏。
接下来要定义派生类CTriangle，并放到共享库（.so）中：
/*+********************************************************/
/* .h */
#ifndef __TRIANGLE_H__
#define __TRIANGLE_H__
#include "polygon.h"
#include <iostream>
class CTriangle : public CPolygon
{
public:
virtual double area(void) const;
};
#endif /* __TRIANGLE_H__ */
/* .cpp */
#include ".h"
extern "C"
{
void * create()
{
return new CTriangle;
}
}
double CTriangle::area(void) const
{
std::cout << "area of " << std::endl;
return 0;
}
/*-********************************************************/
其中定义了函数"create"用来创建CTriangle类对象，该函数可让主程序获得CTriangle对象指针，从而可以访问CTriangle类对象。主程序通过调用dlsym获取指向该函数的指针，需要指出的是，由于dlsym被设计成c-style方式，因此调用c++定义的函数时，需要加上extern "C"
那么主程序是如何调用共享库的呢，代码片段如下：
/*+********************************************************/
typedef CPolygon* create_t();
void * handle = dlopen(".so", RTLD_LAZY);
if( !handle )
{
std::cerr << dlerror() << std::endl;
exit(1);
}
create_t * create_ = (create_t *)dlsym(handle, "create");
CPolygon * pObj = create_();
if( 0 != pObj )
{
pObj->area();
}
delete pObj;
dlclose(handle);
/*-********************************************************/
主程序通过dlopen打开.so，然后通过dlsym得到库中的函数create指针，调用create后返回了指向CTriangle类对象的指针，类型是CPolygon的，由于虚函数的多态性， pObj->area() 实际是调用了CTriangle::area.
好了，插件技术就是这么简单，回顾一下实现过程：写一个基类，定义接口函数，然后在共享库中写派生类，最后在主程序运行时刻打开共享库（dlopen），并通过create函数得到指向新创建的派生类对象的指针，然后利用虚函数的多态性，调用派生类的各种方法。不过进一步使用后你可能会发现，这样实现会有些问题：
1. 每写一个派生类就需要重写一个create函数
注意到CTriangle类实现时定义的create函数必须返回 new CTriangle：
extern "C"
{
void * create()
{
return new CTriangle;
}
}
那么如果再建一个类比如CRectangle， create函数必须重写，返回 new CRectangle
这样做一方面麻烦，另外CTriangle、CRectangle两个类不能放到同一个共享库中，否则会编译时刻提示重复定义错误。
2. 主程序无法判断create函数返回的是哪个类所创建的对象
当只有一个基类（CPolygon）时主程序当然知道返回的是CPolygon派生类的对象指针：
create_t * create_ = (create_t *)dlsym(handle, "create");
CPolygon * pObj = create_();
假如有多个基类，根据这些基类派生出不同类型的类时，无法在主程序中判断使用哪个基类指针。
3. 操作繁琐
没有一个统一的操作界面，实现共享库的加载、卸载、派生类对象的创建，特别是当需要加载一个目录下所有的共享库时，感觉一个一个地加载太麻烦了，能不能批量加载呢。
通过动态类加载和建立Helper类可以很好地解决上述问题，其中dynclass.h/dynclass.cpp中实现了动态加载类对象，pluginhelper.h/pluginhelper.cpp实现了Plugin Helper，具体细节见附件。
下面简单介绍一下使用步骤：
1. 首先定义基类（CPolygon），方法同上。
2. 在共享库中实现派生类
比如CTriangle：
/*+********************************************************/
/* .h */
#ifndef __TRIANGLE_H__
#define __TRIANGLE_H__
#include "polygon.h"
#include <iostream>
class CTriangle : public CPolygon
{
public:
virtual double area(void) const;
};
#endif /* __TRIANGLE_H__ */
/* .cpp */
#include ".h"
#include "dynclass.h"
DYN_DECLARE(CTriangle);
double CTriangle::area(void) const
{
std::cout << "area of " << std::endl;
return 0;
}
/*-********************************************************/
注意到此时派生类的实现（.cpp）中已没有了那个讨厌的create了，被我偷偷放到
dynclass.cpp中了：
extern "C"
{
void * createByClassName(const char * strClassName)
{
return DYN_CREATE(strClassName);
}
}
由于对任何派生类而言，该函数的实现都一样，因此只需要实现一次，对使用者是不可见的,这样了从派生类中拿走的目的。
另外增加了一个宏：DYN_DECLARE(CTriangle); 参数是类名（这里用到了RTTI),每个派生类对应一个这样的宏，该类就可以支持类对象的动态加载了，需要包含头文件dynclass.h
3. 在主程序中如何使用
使用起来也非常简单,在主程序（main.cpp）中：
/*+********************************************************/
...
#include "pluginhelper.h"
#include "polygon.h"
...
CPluginHelper pluginHelper;
pluginHelper.Load( "./plugin", "*.so" );
CPolygon * pbase = (CPolygon *)pluginHelper.Create("CTriangle");
if( 0 != pbase )
{
pbase->area();
}
delete pbase;
pluginHelper.Unload( "./plugin", "*.so" );
/*-********************************************************/
首先定义CPluginHelper对象，调用Load方法加载共享库，其中第一个参数是共享库的路径，第二个参数是共享库的名称，共享库名支持模式匹配，这里表示要加载./plugin目录所有so共享库，当然也可以是某个具体的共享库名。
随后可以通过CPluginHelper::Create方法，根据类名称创建该类的对象，实现了参数化创建对象的目的，然后就是对该对象的调用，当不用该对象时，需要调用delete来删除。
最后，调用CPluginHelper::Unload将指定共享库卸载。
本文提供了linux下的实现插件技术的方法，其实下在window下也一样，可以用Loadlibrary代替dlopen，用GetProcAddress代替dlsym，具体实现就不细说了。
浙公网安备 33010602011771号