Skip to content
TheChatArchiveThe Chat Archive
gpt-3.5-turbo-0301· openaiHugging Face Suzhen/CodeChat

linux c++做热加载动态库,如何处理多态呢?如父类在动态库A,子类在动态库B,在动态库A中创建子类对象

  1. User

    linux c++做热加载动态库,如何处理多态呢?如父类在动态库A,子类在动态库B,在动态库A中创建子类对象

  2. Assistant

    在C++中,多态性是通过虚函数来实现的。在动态库A中创建子类对象时,必须确保动态库B已经被加载,并且可以访问动态库B中的类定义。可以使用dlopen和dlsym函数来加载和获取动态库B中的类定义。

    1. 加载动态库B

    使用dlopen函数加载动态库B:

    void* handle = dlopen("libB.so", RTLD_NOW | RTLD_GLOBAL);
    if(handle == NULL){
        // 处理错误
    }
    
    1. 获取子类定义

    使用dlsym函数获取动态库B中的子类定义:

    typedef Base* (*create_func)();
    create_func create = (create_func)dlsym(handle, "createChild");
    if(create == NULL){
        // 处理错误
    }
    
    1. 创建子类对象

    使用获取的create函数创建子类对象:

    Base* obj = create();
    

    完整的代码如下:

    #include <dlfcn.h>
    
    typedef void (*Func)(void);
    
    class Base{
    public:
        virtual void foo(){
            printf("Base foo\n");
        };
    };
    
    class Child : public Base{
    public:
        virtual void foo(){
            printf("Child foo\n");
        };
    };
    
    typedef Base* (*create_func)();
    create_func create_child;
    
    int main(int argc, char* argv[]){
        void* handle = dlopen("libchild.so", RTLD_NOW | RTLD_GLOBAL);
        if(handle == NULL){
            printf("%s\n", dlerror());
            return 0;
        }
        create_child = (create_func)dlsym(handle, "create_child");
        if(create_child == NULL){
            printf("%s\n", dlerror());
            return 0;
        }
        Base* obj = create_child();
        obj->foo();
        return 0;
    }
    

    其中,libchild.so为动态库B,包含子类Child的定义和create_child函数的实现。在动态库A中,包含父类Base的定义并创建子类对象。

  3. User

    如果是main函数调用动态库A的函数,动态库A的函数再创建动态库B。有办法将热加载的操作放在main函数,为不是放在动态库A吗

  4. Assistant

    对于动态库B的创建,可以在main函数中通过dlopen和dlsym动态加载和使用。以下是示例代码:

    #include <dlfcn.h>
    #include <stdio.h>
    
    typedef void (*Func)();
    
    void load_library_b() {
        void* handle_b = dlopen("./libB.so", RTLD_LAZY);
        if (!handle_b) {
            printf("%s\n", dlerror());
            // 处理错误
            return;
        }
    
        Func create_b = (Func)dlsym(handle_b, "create_b");
        if (!create_b) {
            printf("%s\n", dlerror());
            dlclose(handle_b);
            // 处理错误
            return;
        }
    
        // 使用动态库B中的函数
        create_b();
        dlclose(handle_b);
    }
    
    int main() {
        void* handle_a = dlopen("./libA.so", RTLD_LAZY);
        if (!handle_a) {
            printf("%s\n", dlerror());
            // 处理错误
            return 1;
        }
    
        Func create_a = (Func)dlsym(handle_a, "create_a");
        if (!create_a) {
            printf("%s\n", dlerror());
            dlclose(handle_a);
            // 处理错误
            return 1;
        }
    
        // 使用动态库A中的函数
        create_a();
    
        // 加载动态库B并使用
        load_library_b();
    
        dlclose(handle_a);
        return 0;
    }
    

    在该示例代码中,main函数先加载动态库A并调用其中的函数create_a,然后通过load_library_b函数加载动态库B并使用其中的函数create_b。注意,在使用完动态库B后,要调用dlclose函数关闭动态库B,以释放资源。

  5. User

    在上面的例子中,补充一下动态库A调用动态库B的示例

  6. Assistant

    假设动态库A和动态库B中分别定义了Base类和Child类,其中Child类继承自Base类。动态库A中的create_child函数创建一个Child类对象,动态库B中的create_base函数创建一个Base类对象。在动态库A中还定义了print_child函数,用于输出Child类对象的信息。现在需要在动态库A中调用动态库B中的create_base函数创建Base类对象,并将该对象传递给print_child函数打印信息。以下是解决方案:

    动态库A定义的Child类

    class Child : public Base {
    public:
        virtual ~Child() {}
        virtual void foo() {
            printf("Child foo\n");
        }
    
        virtual void print() {
            printf("Child print\n");
        }
    };
    
    // 创建Child类对象
    extern "C" Child* create_child() {
        return new Child();
    }
    
    // 打印Child类对象信息
    extern "C" void print_child(Child* child) {
        child->print();
    }
    

    动态库B定义的Base类

    class Base {
    public:
        virtual ~Base() {}
        virtual void foo() {
            printf("Base foo\n");
        }
    };
    
    // 创建Base类对象
    extern "C" Base* create_base() {
        return new Base();
    }
    

    在动态库A中调用create_base函数并向print_child函数传递对象

    typedef Base* (*create_base_func_t)();
    create_base_func_t create_base_func = (create_base_func_t)dlsym(handle_b, "create_base");
    
    if (create_base_func == nullptr) {
        // 处理错误
        return;
    }
    
    Base* base_obj = create_base_func();
    Child* child_obj = dynamic_cast<Child*>(base_obj);
    
    if (child_obj == nullptr) {
        // 处理类型转换错误
        return;
    }
    
    print_child(child_obj);
    

    在以上代码中,首先通过dlsym函数获取动态库B中的create_base函数,然后调用该函数创建Base类对象。由于Child类继承自Base类,因此可以使用dynamic_cast将Base类指针转换为Child类指针,以调用Child类的print函数打印信息。注意,dynamic_cast转换可能会失败,因此需要检查child_obj指针是否为空,以防止使用空指针引起程序崩溃。

  7. User

    在main函数调用动态库B中的create_base函数创建一个Base类对象,在动态库B中调用动态库A中的create_child函数创建一个Child类对象,并执行foo函数,而且在main函数动态加载动态库A

  8. Assistant

    以下为实现方案。

    动态库A中的Child类和create_child函数

    class Child : public Base {
    public:
        virtual void foo() {
            printf("Child foo\n");
        };
    };
    
    extern "C" Child* create_child() {
        return new Child();
    }
    

    main函数动态加载并调用动态库B中的create_base函数,并向该函数传递一个函数指针,使其能够在动态库B中调用动态库A的create_child函数创建一个Child类对象,并执行foo函数。

    #include <dlfcn.h>
    #include <functional>
    
    typedef Base* (*create_base_func_t)();
    typedef Child* (*create_child_func_t)();
    
    int main() {
        void* handle_b = dlopen("./libB.so", RTLD_LAZY);
        if (!handle_b) {
            printf("%s\n", dlerror());
            return 1;
        }
    
        create_base_func_t create_base_func = (create_base_func_t)dlsym(handle_b, "create_base");
        if (!create_base_func) {
            printf("%s\n", dlerror());
            dlclose(handle_b);
            return 1;
        }
    
        auto func = [](create_child_func_t create_child_func) {
            Child* child = create_child_func();
            child->foo();
            delete child;
        };
    
        func((create_child_func_t)dlsym(handle_b, "create_child"));
    
        dlclose(handle_b);
        return 0;
    }
    

    以上代码中,通过dlsym函数获取动态库B中的create_base和create_child函数,并使用std::function和Lambda表达式创建了一个函数指针func,该指针可以在传递create_child函数指针的同时,调用该函数并执行foo函数。

    在main函数中,使用create_base_func函数创建了一个Base类对象,并将func函数指针作为参数传递给了create_base函数。在动态库B中,create_base函数创建了一个函数对象,并调用该对象执行foo函数。

    动态库B中的Base类和create_base函数

    class Base {
    public:
        virtual void foo() {
            printf("Base foo\n");
        };
    };
    
    typedef std::function<void(create_child_func_t)> func_t;
    
    extern "C" void create_base(func_t func) {
        func((create_child_func_t)dlsym(RTLD_DEFAULT, "create_child"));
    }
    

    其中,func_t类型为std::function类型,包含一个参数create_child_func_t,即指向create_child函数的指针。create_base函数的参数为func_t,即函数对象,可以使用该对象调用create_child函数,在内部创建一个Child类对象并执行foo函数。注意,由于create_child函数在动态库A中定义,因此在动态库B中需要使用dlsym函数获取其指针,以便可以正确地调用。

  9. User

    RTLD_DEFAULT是什么含义

  10. Assistant

    RTLD_DEFAULT是dlsym函数中指定符号库句柄(handle)参数的一种特殊取值。它表示使用已经加载的所有共享库中的符号来查找指定名称的符号。也就是说,如果RTLD_DEFAULT作为handle参数传递给dlsym函数,dlsym会在所有已经加载的共享库中查找指定名称的符号,并返回找到的第一个符号的地址。

    RTLD_DEFAULT主要用于被调用的共享库里面想要引用调用者的函数或变量时使用,因为它能够避免在代码中明确指定调用者的共享库句柄。在这种情况下,使用RTLD_DEFAULT参数是比较方便和简单的一种方法。

    需要注意的是,如果符号在多个共享库中都存在,并且这些库中的符号定义不同,那么dlsym将只返回其中一个符号的地址。因此,使用RTLD_DEFAULT参数需要确保所有被加载的共享库之间的符号唯一性。