使用dlopenC++动态库的函数符号的常规做法

文章目录

一、Name Mangling
二、extern "C"
三、Loading Functions
四、Loading Classes
参考

一、Name Mangling

在 C 中，符号名称与函数名称相同：strcpy 的符号将是 strcpy，因为在 C 中没有两个非静态函数可以具有相同的名称。

因为 C++ 允许重载（具有相同名称但不同参数的不同函数）并且具有许多 C 所没有的功能（如类、成员函数、异常规范），所以不可能简单地使用函数名称作为符号名称。

为了解决这个问题，C++ 使用所谓的name mangling，它将函数名称和所有必要的信息（例如参数的数量和大小）转换为一些只有编译器知道的看起来奇怪的字符串。
例如，"foo "的mangled name可能看起来像 foo@4%6^。或者，它甚至可能不包含 "foo "这个词。

二、extern “C”

C++ 有一个特殊的关键字来声明具有 C 绑定的函数：extern “C”。声明为 extern “C” 的函数使用函数名称作为符号名称，就像 C 函数一样。因此，只有非成员函数可以声明为 extern “C”，并且不能重载它们。

extern “C” 的函数可以包含 C++ 代码，这样的函数是一个full-featured的 C++ 函数。

使用 extern “C” 的目的是为了在C++代码中正确处理C语言的命名约定和链接规则。它通常用于确保C++编译器正确处理C语言的全局变量或函数的命名。

三、Loading Functions

在 C++ 中，函数的加载方式与 C 语言相同，都是使用 dlsym。要加载的函数必须限定为 extern “C”，以避免符号名被混淆。

main.cpp:

#include <iostream>
#include <dlfcn.h>int main() {using std::cout;using std::cerr;cout << "C++ dlopen demo\n\n";// open the librarycout << "Opening hello.so...\n";void* handle = dlopen("./hello.so", RTLD_LAZY);if (!handle) {cerr << "Cannot open library: " << dlerror() << '\n';return 1;}// load the symbolcout << "Loading symbol hello...\n";typedef void (*hello_t)();// reset errorsdlerror();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 calculationcout << "Calling hello...\n";hello();// close the librarycout << "Closing library...\n";dlclose(handle);
}

hello.cpp:


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

Makefile：

# This file is part of the C++ dlopen mini HOWTO. You can find the complete
# HOWTO and/or updated versions at
# http://www.isotton.com/howtos/C++-dlopen-mini-HOWTO/
#
# Copyright 2002-2006 Aaron Isotton <aaron@isotton.com>
# Licensed under the GNU GPL.example1: main.cpp hello.so$(CXX) $(CXXFLAGS) -o example1 main.cpp -ldlhello.so: hello.cpp$(CXX) $(CXXFLAGS) -shared -o hello.so hello.cppclean:rm -f example1 hello.so.PHONY: clean

函数 hello 定义在 hello.cppas extern “C” 中；它通过 dlsym 调用加载到 main.cpp 中。该函数必须限定为 extern “C”，否则我们将不知道它的符号名称

extern “C” 和extern “C” {}声明的区别：

第一种（内联）形式是具有 extern linkage 和 C language linkage的声明；第二个仅影响C language linkage。

（1）函数声明
extern "C" int foo;
extern "C" void bar();等价于
extern "C" {extern int foo;extern void bar();
}  （2）变量声明
extern "C" int foo;extern "C" {int foo;
}

在第一种声明方式extern “C” int foo;中，只是单独将变量foo声明为按照C语言的链接规则进行编译和链接。这意味着foo变量在C++代码中仍然保持其原始的命名和类型。
而在第二种声明方式extern “C” {
int foo;
}中，使用了一个代码块将foo包裹起来。这种方式告诉编译器，代码块内的所有变量都按照C语言的链接规则进行处理。所以此时的foo变量也会在C++代码中具有C语言的链接规则。
总结来说，两种声明方式都可以达到使用C语言链接规则的目的，但第二种方式可以批量地将多个变量进行声明。

四、Loading Classes

加载类要困难一些，因为我们需要的是类的实例，而不仅仅是指向函数的指针。

我们无法使用 new 创建类的实例，因为类没有在可执行文件中定义，而且（在某些情况下）我们甚至不知道它的名称。

我们可以通过多态性来解决这个问题。我们在可执行文件中定义一个带有虚拟成员的接口基类，在模块中定义一个派生的实现类。一般来说，接口类是抽象的（如果一个类有纯粹的虚拟函数，它就是抽象的）。

由于类的动态加载通常用于插件（插件必须公开一个定义明确的接口），因此我们无论如何都必须定义一个接口和派生实现类。

接下来，我们在模块中定义了两个额外的辅助函数，即类工厂函数。其中一个函数创建一个类的实例，并返回一个指向该实例的指针。另一个函数接收一个指向由类工厂创建的类的指针，并将其销毁。这两个函数被限定为 extern “C”。

要使用模块中的类，请使用 dlsym 加载这两个工厂函数，就像加载 hello 函数一样；然后，我们就可以创建和销毁任意数量的实例了。

main.cc

#include "polygon.hpp"
#include <iostream>
#include <dlfcn.h>int main() {using std::cout;using std::cerr;// load the triangle libraryvoid* triangle = dlopen("./triangle.so", RTLD_LAZY);if (!triangle) {cerr << "Cannot load library: " << dlerror() << '\n';return 1;}// reset errorsdlerror();// load the symbolscreate_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 classpolygon* poly = create_triangle();// use the classpoly->set_side_length(7);cout << "The area is: " << poly->area() << '\n';// destroy the classdestroy_triangle(poly);// unload the triangle librarydlclose(triangle);
}

polygon.hpp:


#ifndef POLYGON_HPP
#define POLYGON_HPPclass 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 factoriesextern "C" polygon* create() {return new triangle;
}extern "C" void destroy(polygon* p) {delete p;
}

Makefile：

# This file is part of the C++ dlopen mini HOWTO. You can find the complete
# HOWTO and/or updated versions at
# http://www.isotton.com/howtos/C++-dlopen-mini-HOWTO/
#
# Copyright 2002-2006 Aaron Isotton <aaron@isotton.com>
# Licensed under the GNU GPL.example2: main.cpp polygon.hpp triangle.so$(CXX) $(CXXFLAGS) -o example2 main.cpp -ldltriangle.so: triangle.cpp polygon.hpp$(CXX) $(CXXFLAGS) -shared -o triangle.so triangle.cppclean:rm -f example2 triangle.so.PHONY: clean