最新linux下C++动态链接C++库示例详解.docx
《最新linux下C++动态链接C++库示例详解.docx》由会员分享，可在线阅读，更多相关《最新linux下C++动态链接C++库示例详解.docx（14页珍藏版）》请在冰豆网上搜索。
最新linux下C++动态链接C++库示例详解
linux下C++动态链接C++库示例详解
linux下C++动态链接C++库示例详解2013-06-2723:
10:
53
分类：
C/C++
注意其中使用函数返回基类指针的用法，因为Linux的动态链接库不能像MFC中那样直接导出类
一、介绍
如何使用dlopenAPI动态地加载C++函数和类，是UnixC++程序员经常碰到的问题。
事实上，情况偶尔有些复杂，需要一些解释。
这正是写这篇miniHOWTO的缘由。
理解这篇文档的前提是对C/C++语言中dlopenAPI有基本的了解。
这篇HOWTO的维护链接是:
二、问题所在
有时你想在运行时加载一个库（并使用其中的函数），这在你为你的程序写一些插件或模块架构的时候经常发生。
在C语言中，加载一个库轻而易举（调用dlopen、dlsym和dlclose就够了），但对C++来说，情况稍微复杂。
动态加载一个C++库的困难一部分是因为C++的namemangling
（译者注：
也有人把它翻译为“名字毁坏”，我觉得还是不翻译好），
另一部分是因为dlopenAPI是用C语言实现的，因而没有提供一个合适的方式来装载类。
在解释如何装载C++库之前，最好再详细了解一下namemangling。
我推荐您了解一下它，即使您对它不感兴趣。
因为这有助于您理解问题是如何产生的，如何才能解决它们。
1.NameMangling
在每个C++程序（或库、目标文件）中，
所有非静态（non-static）函数在二进制文件中都是以“符号（symbol）”形式出现的。
这些符号都是唯一的字符串，从而把各个函数在程序、库、目标文件中区分开来。
在C中，符号名正是函数名：
strcpy函数的符号名就是“strcpy”，等等。
这可能是因为两个非静态函数的名字一定各不相同的缘故。
而C++允许重载（不同的函数有相同的名字但不同的参数），
并且有很多C所没有的特性──比如类、成员函数、异常说明──几乎不可能直接用函数名作符号名。
为了解决这个问题，C++采用了所谓的namemangling。
它把函数名和一些信息（如参数数量和大小）杂糅在一起，
改造成奇形怪状，只有编译器才懂的符号名。
例如，被mangle后的foo可能看起来像foo@4%6^，或者，符号名里头甚至不包括“foo”。
其中一个问题是，C++标准（目前是[ISO14882]）并没有定义名字必须如何被mangle，
所以每个编译器都按自己的方式来进行namemangling。
有些编译器甚至在不同版本间更换mangling算法（尤其是g++2.x和3.x）。
即使您搞清楚了您的编译器到底怎么进行mangling的，从而可以用dlsym调用函数了，
但可能仅仅限于您手头的这个编译器而已，而无法在下一版编译器下工作。
三、类
使用dlopenAPI的另一个问题是，它只支持加载函数。
但在C++中，您可能要用到库中的一个类，而这需要创建该类的一个实例，这不容易做到。
四、解决方案
1.extern"C"
C++有个特定的关键字用来声明采用Cbinding的函数：
extern"C"。
用extern"C"声明的函数将使用函数名作符号名，就像C函数一样。
因此，只有非成员函数才能被声明为extern"C"，并且不能被重载。
尽管限制多多，extern"C"函数还是非常有用，因为它们可以象C函数一样被dlopen动态加载。
冠以extern"C"限定符后，并不意味着函数中无法使用C++代码了，
相反，它仍然是一个完全的C++函数，可以使用任何C++特性和各种类型的参数。
2.加载函数
在C++中，函数用dlsym加载，就像C中一样。
不过，该函数要用extern"C"限定符声明以防止其符号名被mangle。
示例1.加载函数
代码:
//----------
//main.cpp:
//----------
#include
#include
intmain（）{
usingstd:
:
cout;
usingstd:
:
cerr;
cout<<"C++dlopendemo\n\n";
//openthelibrary
cout<<"Openinghello.so...\n";
void*handle=dlopen（"./hello.so",RTLD_LAZY）;
if（!
handle）{
cerr<<"Cannotopenlibrary:
"<return1;
}
//loadthesymbol
cout<<"Loadingsymbolhello...\n";
typedefvoid（*hello_t）（）;
//reseterrors
dlerror（）;
hello_thello=（hello_t）dlsym（handle,"hello"）;
constchar*dlsym_error=dlerror（）;
if（dlsym_error）{
cerr<<"Cannotloadsymbol'hello':
"<dlclose（handle）;
return1;
}
//useittodothecalculation
cout<<"Callinghello...\n";
hello（）;
//closethelibrary
cout<<"Closinglibrary...\n";
dlclose（handle）;
}
//----------
//hello.cpp:
//----------
#include
extern"C"voidhello（）{
std:
:
cout<<"hello"<<'\n';
}
在hello.cpp中函数hello被定义为extern"C"。
它在main.cpp中被dlsym调用。
函数必须以extern"C"限定，否则我们无从知晓其符号名。
警告：
extern"C"的声明形式有两种：
上面示例中使用的那种内联（inline）形式extern"C"，
还有只用花括号的extern"C"{...}这种。
第一种内联形式声明包含两层意义：
外部链接（externlinkage）和C语言链接（languagelinkage），
而第二种仅影响语言链接。
下面两种声明形式等价：
代码:
extern"C"intfoo;
extern"C"voidbar（）;
和代码:
extern"C"{
externintfoo;
externvoidbar（）;
}
对于函数来说，extern和non-extern的函数声明没有区别，但对于变量就有不同了。
如果您声明变量，请牢记：
代码:
extern"C"intfoo;
和代码:
extern"C"{
intfoo;
}
是不同的物事（译者注：
简言之，前者是个声明;而后者不仅是声明，也可以是定义）。
进一步的解释请参考[ISO14882],7.5,特别注意第7段;
或者参考[STR2000]，9.2.4。
在用extern的变量寻幽访胜之前，请细读“其他”一节中罗列的文档。
3.加载类
加载类有点困难，因为我们需要类的一个实例，而不仅仅是一个函数指针。
我们无法通过new来创建类的实例，因为类不是在可执行文件中定义的，况且（有时候）我们连它的名字都不知道。
解决方案是：
利用多态性！
我们在可执行文件中定义一个带虚成员函数的接口基类，而在模块中定义派生实现类。
通常来说，接口类是抽象的（如果一个类含有虚函数，那它就是抽象的）。
因为动态加载类往往用于实现插件，
这意味着必须提供一个清晰定义的接口──我们将定义一个接口类和派生实现类。
接下来，在模块中，我们会定义两个附加的helper函数，
就是众所周知的“类工厂函数（classfactoryfunctions）（译者注：
或称对象工厂函数）”。
其中一个函数创建一个类实例，并返回其指针;
另一个函数则用以销毁该指针。
这两个函数都以extern"C"来限定修饰。
为了使用模块中的类，我们用dlsym像示例1中加载hello函数那样加载这两个函数，
然后我们就可以随心所欲地创建和销毁实例了。
示例2.加载类
我们用一个一般性的多边形类作为接口，而继承它的三角形类（译者注：
正三角形类）作为实现。
代码:
//----------
//main.cpp:
//----------
#include"polygon.hpp"
#include
#include
intmain（）{
usingstd:
:
cout;
usingstd:
:
cerr;
//loadthetrianglelibrary
void*triangle=dlopen（"./triangle.so",RTLD_LAZY）;
if（!
triangle）{
cerr<<"Cannotloadlibrary:
"<return1;
}
//reseterrors
dlerror（）;
//loadthesymbols
create_t*create_triangle=（create_t*）dlsym（triangle,"create"）;
constchar*dlsym_error=dlerror（）;
if（dlsym_error）{
cerr<<"Cannotloadsymbolcreate:
"<return1;
}
destroy_t*destroy_triangle=（destroy_t*）dlsym（triangle,"destroy"）;
dlsym_error=dlerror（）;
if（dlsym_error）{
cerr<<"Cannotloadsymboldestroy:
"<return1;
}
//createaninstanceoftheclass
polygon*poly=create_triangle（）;
//usetheclass
poly->set_side_length（7）;
cout<<"Theareais:
"<area（）<<'\n';
//destroytheclass
destroy_triangle（poly）;
//unloadthetrianglelibrary
dlclose（triangle）;
}
主程序的编译与运行:
$g++-Wall-g-rdynamic-ldlmain.cpp-ocompile_c++LIBc++
$./compile_c++LIBc++
Theareais:
42.4352
//----------
//polygon.hpp:
//----------
#ifndefPOLYGON_HPP
#definePOLYGON_HPP
classpolygon{
protected:
doubleside_length_;
public:
polygon（）:
side_length_（0）{}
virtual~polygon（）{}
voidset_side_length（doubleside_length）{
side_length_=side_length;
}
virtualdoublearea（）const=0;
};
//thetypesoftheclassfactories
typedefpolygon*create_t（）;
typedefvoiddestroy_t（polygon*）;
#endif
//----------
//triangle.cpp:
//----------
#include"polygon.hpp"
#include
classtriangle:
publicpolygon{
public:
virtualdoublearea（）const{
returnside_length_*side_length_*sqrt（3）/2;
}
};
//theclassfactories
extern"C"polygon*create（）{
returnnewtriangle;
}
extern"C"voiddestroy（polygon*p）{
deletep;
}
动态库的编译:
$g++-Wall-g-fPIC-otriangle.so-sharedtriangle.cpp
加载类时有一些值得注意的地方：
◆你必须（译者注：
在模块或者说共享库中）同时提供一个创造函数和一个销毁函数，
且不能在执行文件内部使用delete来销毁实例，只能把实例指针传递给模块的销毁函数处理。
这是因为C++里头，new操作符可以被重载;
这容易导致new-delete的不匹配调用，造成莫名其妙的内存泄漏和段错误。
这在用不同的标准库链接模块和可执行文件时也一样。
◆接口类的析构函数在任何情况下都必须是虚函数（virtual）。
因为即使出错的可能极小，近乎杞人忧天了，但仍旧不值得去冒险，反正额外的开销微不足道。
如果基类不需要析构函数，定义一个空的（但必须虚的）析构函数吧，否则你迟早要遇到问题，我向您保证。
你可以在comp.lang.c++FAQ（）的
第20节了解到更多关于该问题的信息。
示例3:
/*!
******************************************************************************
*\File
*arith.h
******************************************************************************
*/
#ifndef__ARITH_H__
#define__ARITH_H__
classArithmetic
{
protected:
intm_iVarA;
intm_iVarB;
public:
voidset_member_var（inta,intb）{
m_iVarA=a;
m_iVarB=b;
}
public:
virtualintadd（）const=0;
//intadd（）;
intsub（）;
intmul（）;
intdiv（）;
intmod（）;
public:
Arithmetic（）:
m_iVarA（0）,m_iVarB（0）{}
virtual~Arithmetic（）{}
};
typedefArithmetic*create_t（）;
typedefvoiddestroy_t（Arithmetic*）;
#endif
/*!
******************************************************************************
*\File
*arith.cpp
******************************************************************************
*/
#include"arith.h"
classarith:
publicArithmetic{
public:
virtualintadd（）const{
return（m_iVarA+m_iVarB）;
}
};
//theclassfactories
extern"C"Arithmetic*create（inta,intb）{
returnnewarith;
}
extern"C"voiddestroy（Arithmetic*p）{
deletep;
}
编译动态库:
$g++-Wall-g-fPIC-oarith.so-sharedarith.cpp
主程序:
/*!
******************************************************************************
*\File
*main.cpp
*\Brief
*C++sourcecode
*\Author
*Hank
******************************************************************************
*/
#include
#include
#include"arith.h"
usingnamespacestd;
intmain（intargc,char*argv[]）
{
inta=4,b=3;
intret=0;
void*p_Handler=dlopen（"./arith.so",RTLD_LAZY）;
if（!
p_Handler）
{
printf（"%s\n",dlerror（））;
exit
（1）;
}
dlerror（）;
create_t*create_arith=（create_t*）dlsym（p_Handler,"create"）;
constchar*dlsym_error=dlerror（）;
if（dlsym_error）{
cerr<<"Cannotloadsymbolcreate:
"<return1;
}
destroy_t*destroy_arith=（destroy_t*）dlsym（p_Handler,"destroy"）;
dlsym_error=dlerror（）;
if（dlsym_error）{
cerr<<"Cannotloadsymboldestroy:
"<return1;
}
Arithmetic*arith_obj=create_arith（）;
arith_obj->set_member_var（a,b）;
ret=arith_obj->add（）;
cout<
destroy_arith（arith_obj）;
dlclose（p_Handler）;
return0;
}
编译与运行：
$g++-Wall-g-rdynamic-ldlmain.cpp-ocompile_c++LIBc++
$./compile_c++LIBc++
4+3=7
升级会员 