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. 加载简单函数

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

main.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);
}

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

//----------
// hello.cpp:
//----------
#include

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

extern "C" int add(int a, int b){
    return a + b;
}

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

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中指定了 ./ 目录,如下图所示。
Selection_142

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

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

Selection_143

示例程序2. 加载类

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

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

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

//----------
//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

这里把我小小的纠结了一下,函数名后面加 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这里就不用再添加指针符号。

typedef int (*add_t)(int, int);
add_t add = (add_t) dlsym(handle, "add";

———————————————-main.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);
}

———————————————-triangle.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;
}

go on..

好了,现在来编译打包,命令如下:

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

结果如下图所示

Selection_144

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

Leave a Reply

Your email address will not be published.