用C++面向对象的方式动态加载so的方法

很好，用C++面向对象的方式动态加载so的方法可以通过以下步骤实现：

1. 准备工作

在开始使用C++动态加载so前，需要安装相关的开发库，具体步骤可以参考系统文档或者官方网站的说明。以Ubuntu为例，安装GCC开发环境和动态库加载库libdl的命令为：

$ sudo apt-get install build-essential
$ sudo apt-get install libdl-dev

2. 加载动态库

加载动态库需要使用到函数dlopen()，该函数可以返回一个指向动态库的指针，函数原型为：

void* dlopen(const char* filename, int flags);

其中，filename参数指定的是动态库的路径和名称，可以是相对路径或者绝对路径。flags参数指定打开方式，常用的有RTLD_LAZY、RTLD_NOW和RTLD_GLOBAL等，其中RTLD_LAZY表示在需要时才解析符号，RTLD_NOW则是在dlopen()调用时就解析所有符号。RTLD_GLOBAL和RTLD_LOCAL用于指定符号是否全局可见。返回值类型是void*，需要强制转换为加载so的类型。

3. 获取函数指针

通过dlsym()函数获取动态库中函数的指针，函数原型为：

void* dlsym(void* handle, const char* symbol);

其中，handle参数为dlopen()返回的指针，symbol参数为函数名或者变量名。使用dlsym()获取函数指针后，可以直接调用该函数。

示例1：动态加载共享库并调用函数

下面示例如何动态加载共享库并调用其中一个计算函数：

#include <iostream>
#include <dlfcn.h>

using namespace std;

class SharedLibrary {
public:
    typedef int (*CalculateFunc)(int, int);
    SharedLibrary(const char* libPath) : handle(dlopen(libPath, RTLD_LAZY)) {}

    ~SharedLibrary() {
        if (handle != NULL) {
            dlclose(handle);
        }
    }

    CalculateFunc getCalculateFunc() const {
        if (handle == NULL) {
            return NULL;
        }
        return (CalculateFunc)dlsym(handle, "add");
    }

private:
    void* handle;
};

int main() {
    SharedLibrary lib("./libcalculate.so");
    SharedLibrary::CalculateFunc func = lib.getCalculateFunc();
    if (func != NULL) {
        int result = func(10, 20);
        cout << "result = " << result << endl;
    } else {
        cout << "open lib failed." << endl;    
    }
    return 0;
}

上面的代码会加载libcalculate.so共享库并调用其中的add()函数，从而实现了动态加载so的功能。

示例2：使用动态库接口实现计算器

下面示例展示了通过动态库接口和插件的方式实现了一个简单的计算器：

#include <iostream>
#include <vector>
#include <dlfcn.h>

using namespace std;

// 动态库接口类
class Plugin {
public:
    Plugin(const char* libPath) : handle(dlopen(libPath, RTLD_LAZY)) {}

    ~Plugin() {
        if (handle != NULL) {
            dlclose(handle);
        }
    }

    typedef int (*CalculateFunc)(int, int);
    CalculateFunc getCalculateFunc() const {
        if (handle == NULL) {
            return NULL;
        }
        return (CalculateFunc)dlsym(handle, "calculate");
    }

private:
    void* handle;
};

// 插件管理器，用于加载和卸载插件
class PluginManager {
public:
    ~PluginManager() {
        clear();
    }

    void loadPlugin(const char* libPath) {
        Plugin* plugin = new Plugin(libPath);
        if (plugin != NULL) {
            plugins.push_back(plugin);
        }
    }

    void clear() {
        for (auto& plugin : plugins) {
            delete plugin;
        }
        plugins.clear();
    }

    int calculate(int a, int b) {
        int result = 0;
        for (auto& plugin : plugins) {
            Plugin::CalculateFunc func = plugin->getCalculateFunc();
            if (func != NULL) {
                result = func(a, b);
            }
        }
        return result;
    }

private:
    vector<Plugin*> plugins;
};

// 主函数
int main() {
    PluginManager pluginMgr;
    pluginMgr.loadPlugin("./libplugin1.so");
    pluginMgr.loadPlugin("./libplugin2.so");
    int result = pluginMgr.calculate(5, 7);
    cout << "result = " << result << endl;
    return 0;
}

上面的代码中，插件可以通过动态库接口来实现。主程序通过PluginManager管理插件，可以分别加载和卸载插件，并使用calculate()函数实现所有插件的计算功能。