C++调用自己的.so

由于一些原因，需要在C++中动态加载自己写的动态链接库（.so）文件。网络上的资源挺多，我也看了不少，参考最多的是下面这三篇

1. dlopen加载c++ 函数及类： http://blog.csdn.net/lwj1396/article/details/5204484

2. 上一篇的英文版本： http://www.isotton.com/devel/docs/C++-dlopen-mini-HOWTO/C++-dlopen-mini-HOWTO.html#theproblem

3. 动态调用动态库方法 .so: http://blog.csdn.net/lbmygf/article/details/7401862

再说一说自己的心得吧。

首先介绍一下动态库和静态库之间的区别

静态库是指编译连接时，把库文件的代码全部加入到可执行文件中，所以生成的文件较大，但运行时，就不再需要库文件了。即，程序与静态库编译链接后，即使删除静态库文件，程序也可正常执行。

动态库正好相反，在编译链接时，没有把库文件的代码加入到可执行文件中，所以生成的文件较小，但运行时，仍需要加载库文件。即，程序只在执行启动时才加载动态库，如果删除动态库文件，程序将会因为无法读取动态库而产生异常。

那么如何调用动态库？如何在C语言下，其实是很简单的（调用dlopen、dlsym和dlclose就够了），但对C++来说，情况稍微复杂。动态加载一个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调用函数了，但可能仅仅限于您手头的这个编译器而已， 而无法在下一版编译器下工作。

解决方案 extern “C”

C++有个特定的关键字用来声明采用C binding的函数：extern “C” 。 用 extern “C”声明的函数将使用函数名作符号名，就像C函数一样。因此，只有非成员函数才能被声明为extern “C”，并且不能被重载。尽管限制多多，extern “C”函数还是非常有用，因为它们可以象C函数一样被dlopen动态加载。冠以extern “C”限定符后，并不意味着函数中无法使用C++代码了，相反，它仍然是一个完全的C++函数，可以使用任何C++特性和各种类型的参数。

示例程序1. 加载简单函数

目录结构

示例程序1在test1目录下，这个例子也主要是参考第一篇博客写的。有一些修改。

main.cpp的代码如下

[cpp]
//———-
//main.cpp:
//———-
#include
#include

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("libhello.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();

// load the symbol
cout << "Loading symbol add…\n";
typedef int (*add_t)(int, int);

// reset errors
dlerror();
add_t add = (add_t) dlsym(handle, "add");
if (dlsym_error) {
cerr << "Cannot load symbol ‘add’: " << dlsym_error <<
‘\n’;
dlclose(handle);
return 1;
}

// use it to do the calculation
cout << "Calling the add()…\n";
cout << add(98, 99) << " is the result\n";

// close the library
cout << "Closing library…\n";
dlclose(handle);
}

[/cpp]

然后是hello.cpp的代码，一会儿将会把这个源文件编译打包成.so文件。

[cpp]
//———-
// hello.cpp:
//———-
#include

extern "C" void hello() {
std::cout << "hello" << ‘\n’;
}

extern "C" int add(int a, int b){
return a + b;
}
[/cpp]

介绍一下上面用到的接口函数

1)       dlopen

函数原型：void *dlopen(const char *libname,int flag);

功能描述：dlopen必须在dlerror，dlsym和dlclose之前调用，表示要将库装载到内存，准备使用。如果要装载的库依赖于其它库，必须首先装载依赖库。如果dlopen操作失败，返回NULL值；如果库已经被装载过，则dlopen会返回同样的句柄。

参数中的libname一般是库的全路径，这样dlopen会直接装载该文件；如果只是指定了库名称，在dlopen会按照下面的机制去搜寻：

a.根据环境变量LD_LIBRARY_PATH查找

b.根据/etc/ld.so.cache查找

c.查找依次在/lib和/usr/lib目录查找。

flag参数表示处理未定义函数的方式，可以使用RTLD_LAZY或RTLD_NOW。RTLD_LAZY表示暂时不去处理未定义函数，先把库装载到内存，等用到没定义的函数再说；RTLD_NOW表示马上检查是否存在未定义的函数，若存在，则dlopen以失败告终。

2)       dlerror

函数原型：char *dlerror(void);

功能描述：dlerror可以获得最近一次dlopen,dlsym或dlclose操作的错误信息，返回NULL表示无错误。dlerror在返回错误信息的同时，也会清除错误信息。

3)       dlsym

函数原型：void *dlsym(void *handle,const char *symbol);

功能描述：在dlopen之后，库被装载到内存。dlsym可以获得指定函数(symbol)在内存中的位置(指针)。如果找不到指定函数，则dlsym会返回NULL值。但判断函数是否存在最好的方法是使用dlerror函数，

4)       dlclose

函数原型：int dlclose(void *);

功能描述：将已经装载的库句柄减一，如果句柄减至零，则该库会被卸载。如果存在析构函数，则在dlclose之后，析构函数会被调用。

好了，现在来编译打包，命令如下：

$ g++ -shared -fPIC -o libhello.so hello.cpp
$ g++ main.cpp -ldl

在上面dlopen函数中，看到我们传的第一个参数并没有指定路径，只给出了库的名称。那是因为已经在环境变量LD_LIBRARY_PATH中指定了 ./ 目录，如下图所示。

如果你想放在其他目录，修改该环境变量即可。

运行a.out，输入结果如下图所示

示例程序2. 加载类

几篇文章的意思基本都是这样：

加载类有点困难，因为我们需要类的一个实例，而不仅仅是一个函数指针。我们无法通过new来创建类的实例，因为类不是在可执行文件（这里即指由main.cpp编译成的a.out文件）中定义的，况且（有时候）我们连它的名字都不知道。
解决方案是：利用多态性！ 我们在可执行文件中定义一个带虚成员函数的接口基类，而在模块中定义派生实现类。通常来说，接口类是抽象的（如果一个类含有虚函数，那它就是抽象的）。
因为动态加载类往往用于实现插件，这意味着必须提供一个清晰定义的接口──我们将定义一个接口类和派生实现类。
接下来，在模块中，我们会定义两个附加的helper函数，就是众所周知的“类工厂函数（class factory functions）（译者注：或称对象工厂函数）”。其中一个函数创建一个类实例，并返回其指针; 另一个函数则用以销毁该指针。这两个函数都以extern “C”来限定修饰。
为了使用模块中的类，我们用dlsym像示例1中加载hello函数那样加载这两个函数，然后我们就可以随心所欲地创建和销毁实例了。

———————————-polygon.hpp—————————————————————

[cpp]
//———-
//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

[/cpp]

这里把我小小的纠结了一下，函数名后面加 const=0是什么意思呢？两个typedef好像是要定义函数指针，但又不是在定义函数指针。google了一阵以后，大致都了解了。

首先，const 和 =0 没有关系，要分开理解
成员函数后面用 const 修饰，通俗的理解就是在这个函数内不能修改类的成员变量，除非那个成员变量是 mutable 的

=0表示这个成员函数是纯虚函数，也就是它可以没有定义，只有接口，由它的继承类具体定义它的行为，当然，你也可以给它定义缺省的函数体
一个类里如果包含 ＝0 的纯虚函数，那么这个类就是一个抽象类，它不能具体实例化（不能创建它的对象），而只能由它去派生子类

然后是两个typedef，这里其实是typedef了两个函数类型，在后面
create_t* create_triangle = (create_t*) dlsym(triangle, “create”);
的时候是加了指针符号的。
对比一下示例1中的typedef，示例1中是直接定义的函数指针，所以在dlsym这里就不用再添加指针符号。
[cpp]
typedef int (*add_t)(int, int);
add_t add = (add_t) dlsym(handle, "add";
[/cpp]

———————————————-main.cpp———————————————-

[cpp]
//———-
//main.cpp:
//———-
#include "polygon.hpp"
#include
#include

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(10);
cout << "The area is: " << poly->area() << ‘\n’;

// destroy the class
destroy_triangle(poly);

// unload the triangle library
dlclose(triangle);
}
[/cpp]

———————————————-triangle.cpp———————————————-

[cpp]
//———-
//triangle.cpp:
//———-
#include "polygon.hpp"
#include

class triangle : public polygon {
public:
virtual double area() const {
return side_length_ * side_length_ * sqrt(3) / 2;
}
};

// the class factories
extern "C" polygon* create() {
return new triangle;
}

extern "C" void destroy(polygon* p) {
delete p;
}

[/cpp]

go on..

好了，现在来编译打包，命令如下：

$ g++ -shared -fPIC -o triangle.so triangle.cpp
$ g++ main.cpp -ldl
$ ./a.out

结果如下图所示

调用类成功。恩，大致就是这些啦。