同步编译失败

楼主好，当两个动态链接库（a.so和b.so）存在循环依赖时，（即a.so调用b.so的函数，b.so也调用a.so的函数），直接编译会导致符号解析失败。因为传统的隐式依赖链会在编译阶段互相要求对方已存在符号，从而形成死锁。

可以通过 dlopen + dlsym 动态加载实现编译解耦，将隐式依赖转为显式依赖解决，下面是解决步骤

1. 这里以a.cpp为例修改代码逻辑

// a.cpp

#include <dlfcn.h>

#include "a.h"

extern "C" {  // 使用extern "C"避免C++名称修饰

    int add(int a, int b) { 

        // 动态加载b.so

        void* handle = dlopen("libb.so", RTLD_LAZY);

        if (!handle) {

            return -1;

        }

        

        // 获取b.so中的函数指针

        typedef int (*sub_func_t)(int, int);

        sub_func_t sub = (sub_func_t)dlsym(handle, "sub");

        

        int res = sub(a, b);

        dlclose(handle);

        return a + b + res; 

    }

}

2. 调整CMake配置

# A模块的CMakeLists.txt

add_library(a SHARED a.cpp)

# 无需直接链接b.so

# B模块的CMakeLists.txt 

add_library(b SHARED b.cpp)

# 无需直接链接a.so

3. 运行路径管理

在ArkTS侧传递SO沙箱路径：

let projectPath = getContext().bundleCodeDir;

let soPathA = `${projectPath}/libs/${abi}/liba.so`;

let soPathB = `${projectPath}/libs/${abi}/libb.so`;

Native侧通过ArkTS传入的路径加载：

// 在b.cpp中动态加载a.so

void* handle = dlopen(arktsPath, RTLD_LAZY); // arktsPath从ArkTS传入

循环依赖导致编译时链接器无法解析相互引用的符号，传统静态链接方式无法处理a.so与b.so的交叉调用关系

对模块相互依赖进行解耦

// A模块a.cpp改造
extern "C" {
    #include <dlfcn.h>
    typedef int (*FUNC_SUB)(int, int);
    
    int add(int a, int b) {
        void* handle = dlopen("libb.so", RTLD_LAZY);
        FUNC_SUB sub = (FUNC_SUB)dlsym(handle, "sub");
        int res = sub(a, b);
        dlclose(handle);
        return a + b + res;
    }
}

// B模块b.cpp改造
extern "C" {
    #include <dlfcn.h>
    typedef int (*FUNC_ADD)(int, int);
    
    int sub(int a, int b) {
        void* handle = dlopen("liba.so", RTLD_LAZY);
        FUNC_ADD add = (FUNC_ADD)dlsym(handle, "add");
        int res = add(a, b);
        dlclose(handle);
        return a - b + res;
    }
}

参考地址

https://developer.huawei.com/consumer/cn/doc/harmonyos-faqs/faqs-ndk-71