Fortran与C++间含allocatable成员的复杂结构体双向传参方法

基于你使用的Intel Fortran + MSVC 2019 64位 + Qt 6.2.2环境，不要直接尝试内存硬匹配Fortran原生带allocatable属性的UDT——Intel Fortran的可分配数组描述符、嵌套UDT内存偏移属于编译器内部实现，随编译选项、版本变化会发生偏移，硬映射极大概率触发内存错误。

核心实现思路 #

• 跨语言边界仅传递标准C布局的桥接结构体，C++侧桥接类型必须加extern "C"约束，保证无虚函数、成员内存偏移固定；Fortran侧用ISO_C_BINDING模块定义布局完全一致的绑定类型。
• 所有allocatable成员不直接暴露，统一替换为「原始数据指针 + 各维度长度」的组合形式，嵌套结构体递归做相同处理。
• 双向传递时独立编写转换逻辑：Fortran侧负责原生UDT和C桥接结构体的互相转换，C++/Qt侧负责C桥接结构体和Qt原生容器/自定义类型的互相转换，内存所有权边界严格划分。
• 字符数组单独处理：Fortran可分配字符数组不直接映射为char*，统一转换为C风格null结尾字符串数组后再传递，避免长度不匹配导致的越界。

具体代码实现 #

Fortran侧实现 #

! 原有业务类型定义，建议明确指定kind值匹配C侧类型宽度
module example
    use, intrinsic :: iso_c_binding
    implicit none
    type sub_struct
        complex(c_double_complex), allocatable :: complex2(:)
        real(c_double), allocatable :: real2(:, :)
        integer(c_int), allocatable :: ints2(:, :)
        character(:), allocatable :: label2(:)
    end type sub_struct

    type top_struct
        type(sub_struct), allocatable :: sStruct(:)
        complex(c_double_complex), allocatable :: complex1(:)
        real(c_double), allocatable :: real1(:, :)
        integer(c_int), allocatable :: ints1(:, :)
        character(:), allocatable :: label1(:)
    end type top_struct
end module example

! 跨语言桥接模块
module fortran_cpp_bridge
    use, intrinsic :: iso_c_binding
    use example
    implicit none

    ! C兼容子结构体，成员顺序必须和C++侧完全一致
    type, bind(C) :: c_sub_struct
        type(c_ptr)    :: complex2_data
        integer(c_int) :: complex2_len
        type(c_ptr)    :: real2_data
        integer(c_int) :: real2_rows
        integer(c_int) :: real2_cols
        type(c_ptr)    :: ints2_data
        integer(c_int) :: ints2_rows
        integer(c_int) :: ints2_cols
        type(c_ptr)    :: label2_data
        integer(c_int) :: label2_len
    end type c_sub_struct

    ! C兼容顶层结构体
    type, bind(C) :: c_top_struct
        type(c_ptr)    :: sstruct_data
        integer(c_int) :: sstruct_len
        type(c_ptr)    :: complex1_data
        integer(c_int) :: complex1_len
        type(c_ptr)    :: real1_data
        integer(c_int) :: real1_rows
        integer(c_int) :: real1_cols
        type(c_ptr)    :: ints1_data
        integer(c_int) :: ints1_rows
        integer(c_int) :: ints1_cols
        type(c_ptr)    :: label1_data
        integer(c_int) :: label1_len
    end type c_top_struct

    contains
    ! 导出给C++调用：Fortran原生结构体转C桥接结构体
    subroutine convert_fortran_to_c(f_top, c_top_out) bind(C, name="convert_fortran_to_c")
        type(top_struct), intent(in), target :: f_top
        type(c_top_struct), intent(out) :: c_top_out
        ! 实现逻辑：
        ! 1. 对每个可分配数组成员，用c_loc()取连续内存首地址赋值给对应c_ptr成员
        ! 2. 读取数组shape值填充对应长度/行列字段
        ! 3. 嵌套sStruct数组：递归遍历每个sub_struct转换为c_sub_struct，连续存储后取首地址
        ! 4. 字符数组成员：逐个将Fortran字符串转为null结尾C字符串，存储char*数组后取首地址
        ! 注意：临时分配的桥接内存必须配套记录，统一由本侧释放函数回收
    end subroutine convert_fortran_to_c

    ! 导出给C++调用：C桥接结构体转Fortran原生结构体
    subroutine convert_c_to_fortran(c_top_in, f_top_out) bind(C, name="convert_c_to_fortran")
        type(c_top_struct), intent(in) :: c_top_in
        type(top_struct), intent(out) :: f_top_out
        ! 实现逻辑：
        ! 1. 按传入的维度长度，allocate对应Fortran侧可分配成员
        ! 2. 用c_f_pointer()将C指针绑定为Fortran数组指针，批量拷贝数据到已分配内存
        ! 3. 嵌套sStruct数组：遍历c_sub_struct元素递归转换为原生sub_struct
        ! 4. 字符数组：逐个将C风格字符串拷贝到Fortran字符变量
    end subroutine convert_c_to_fortran

    ! 导出给C++调用：释放Fortran侧分配的桥接内存
    subroutine free_bridge_c_top(c_top_ptr) bind(C, name="free_bridge_c_top")
        type(c_ptr), intent(inout) :: c_top_ptr
        ! 回收convert_fortran_to_c中临时分配的子结构体数组、C风格字符串数组等所有桥接内存
    end subroutine free_bridge_c_top
end module fortran_cpp_bridge

禁止使用Fortran默认无kind修饰的real/integer/complex类型，不同编译选项下默认类型宽度会变化，必须显式使用c_double/c_int/c_double_complex等和C侧等宽的kind值。

C++/Qt侧实现 #

#include <QtCore>
#include <complex>
#include <cstdlib>
#include <cstring>

// C兼容桥接结构体声明，成员顺序必须和Fortran侧bind(C)类型完全一致
extern "C" {
    struct CSubStruct {
        std::complex<double>* complex2_data;
        int32_t complex2_len;
        double* real2_data;
        int32_t real2_rows;
        int32_t real2_cols;
        int32_t* ints2_data;
        int32_t ints2_rows;
        int32_t ints2_cols;
        char** label2_data;
        int32_t label2_len;
    };

    struct CTopStruct {
        CSubStruct* sstruct_data;
        int32_t sstruct_len;
        std::complex<double>* complex1_data;
        int32_t complex1_len;
        double* real1_data;
        int32_t real1_rows;
        int32_t real1_cols;
        int32_t* ints1_data;
        int32_t ints1_rows;
        int32_t ints1_cols;
        char** label1_data;
        int32_t label1_len;
    };

    // Fortran导出函数声明
    void convert_fortran_to_c(void* f_top_native, CTopStruct* c_top_out);
    void convert_c_to_fortran(CTopStruct* c_top_in, void* f_top_native_out);
    void free_bridge_c_top(CTopStruct* c_top_ptr);
}

// Qt/C++侧业务使用的原生结构体
struct CppSubStruct {
    std::vector<std::complex<double>> complex2;
    std::vector<std::vector<double>> real2;
    std::vector<std::vector<int32_t>> ints2;
    QStringList label2;
};

struct CppTopStruct {
    std::vector<CppSubStruct> sStruct;
    std::vector<std::complex<double>> complex1;
    std::vector<std::vector<double>> real1;
    std::vector<std::vector<int32_t>> ints1;
    QStringList label1;
};

// C桥接结构体转Qt/C++原生结构体
inline CppTopStruct convertCToCpp(const CTopStruct& c_top) {
    CppTopStruct res{};
    // 1维复数数组直接拷贝
    res.complex1 = QVector<std::complex<double>>(c_top.complex1_data, c_top.complex1_data + c_top.complex1_len).toStdVector();
    
    // 2维实数数组：Fortran为列优先存储，C++为行优先，需要按偏移转换保证索引对应
    res.real1.resize(c_top.real1_rows);
    for (int i = 0; i < c_top.real1_rows; i++) {
        res.real1[i].resize(c_top.real1_cols);
        for (int j = 0; j < c_top.real1_cols; j++) {
            res.real1[i][j] = c_top.real1_data[i + j * c_top.real1_rows];
        }
    }

    // 2维整数数组转换逻辑同实数
    res.ints1.resize(c_top.ints1_rows);
    for (int i = 0; i < c_top.ints1_rows; i++) {
        res.ints1[i].resize(c_top.ints1_cols);
        for (int j = 0; j < c_top.ints1_cols; j++) {
            res.ints1[i][j] = c_top.ints1_data[i + j * c_top.ints1_rows];
        }
    }

    // 字符串数组转QString
    for (int i = 0; i < c_top.label1_len; i++) {
        res.label1.append(QString::fromUtf8(c_top.label1_data[i]));
    }

    // 嵌套子结构体递归转换
    res.sStruct.resize(c_top.sstruct_len);
    for (int i = 0; i < c_top.sstruct_len; i++) {
        const CSubStruct& c_sub = c_top.sstruct_data[i];
        CppSubStruct& cpp_sub = res.sStruct[i];
        cpp_sub.complex2 = QVector<std::complex<double>>(c_sub.complex2_data, c_sub.complex2_data + c_sub.complex2_len).toStdVector();
        // real2、ints2、label2转换逻辑同顶层成员，按相同规则填充即可
    }
    return res;
}

// Qt/C++原生结构体转C桥接结构体
inline CTopStruct convertCppToC(const CppTopStruct& cpp_top) {
    CTopStruct c_top{0};
    // 桥接内存统一用malloc分配，和Fortran侧内存分配逻辑对齐，避免跨语言释放错误
    c_top.complex1_len = static_cast<int32_t>(cpp_top.complex1.size());
    c_top.complex1_data = static_cast<std::complex<double>*>(malloc(sizeof(std::complex<double>) * c_top.complex1_len));
    memcpy(c_top.complex1_data, cpp_top.complex1.data(), sizeof(std::complex<double>) * c_top.complex1_len);

    // 2维实数数组按列优先顺序拷贝
    c_top.real1_rows = static_cast<int32_t>(cpp_top.real1.size());
    c_top.real1_cols = c_top.real1_rows > 0 ? static_cast<int32_t>(cpp_top.real1[0].size()) : 0;
    c_top.real1_data = static_cast<double*>(malloc(sizeof(double) * c_top.real1_rows * c_top.real1_cols));
    for (int i = 0; i < c_top.real1_rows; i++) {
        for (int j = 0; j < c_top.real1_cols; j++) {
            c_top.real1_data[i + j * c_top.real1_rows] = cpp_top.real1[i][j];
        }
    }

    // 2维整数数组转换逻辑同实数
    c_top.ints1_rows = static_cast<int32_t>(cpp_top.ints1.size());
    c_top.ints1_cols = c_top.ints1_rows > 0 ? static_cast<int32_t>(cpp_top.ints1[0].size()) : 0;
    c_top.ints1_data = static_cast<int32_t*>(malloc(sizeof(int32_t) * c_top.ints1_rows * c_top.ints1_cols));
    for (int i = 0; i < c_top.ints1_rows; i++) {
        for (int j = 0; j < c_top.ints1_cols; j++) {
            c_top.ints1_data[i + j * c_top.ints1_rows] = cpp_top.ints1[i][j];
        }
    }

    // 字符串数组转C风格char*数组
    c_top.label1_len = static_cast<int32_t>(cpp_top.label1.size());
    c_top.label1_data = static_cast<char**>(malloc(sizeof(char*) * c_top.label1_len));
    for (int i = 0; i < c_top.label1_len; i++) {
        QByteArray ba = cpp_top.label1[i].toUtf8();
        c_top.label1_data[i] = static_cast<char*>(malloc(ba.size() + 1));
        memcpy(c_top.label1_data[i], ba.constData(), ba.size() + 1);
    }

    // 嵌套子结构体递归转换
    c_top.sstruct_len = static_cast<int32_t>(cpp_top.sStruct.size());
    c_top.sstruct_data = static_cast<CSubStruct*>(malloc(sizeof(CSubStruct) * c_top.sstruct_len));
    for (int i = 0; i < c_top.sstruct_len; i++) {
        const CppSubStruct& cpp_sub = cpp_top.sStruct[i];
        CSubStruct& c_sub = c_top.sstruct_data[i];
        memset(&c_sub, 0, sizeof(CSubStruct));
        // 按顶层成员相同逻辑填充c_sub所有字段即可
    }
    return c_top;
}

// 释放C++侧分配的桥接内存
inline void freeCBridgeStruct(CTopStruct& c_top) {
    free(c_top.complex1_data);
    free(c_top.real1_data);
    free(c_top.ints1_data);
    for (int i = 0; i < c_top.label1_len; i++) free(c_top.label1_data[i]);
    free(c_top.label1_data);
    // 递归释放子结构体内存
    for (int i = 0; i < c_top.sstruct_len; i++) {
        CSubStruct& c_sub = c_top.sstruct_data[i];
        free(c_sub.complex2_data);
        free(c_sub.real2_data);
        free(c_sub.ints2_data);
        for (int j = 0; j < c_sub.label2_len; j++) free(c_sub.label2_data[j]);
        free(c_sub.label2_data);
    }
    free(c_top.sstruct_data);
    memset(&c_top, 0, sizeof(CTopStruct));
}

关键避坑点 #

• 内存所有权严格隔离：Fortran侧分配的桥接内存只能调用free_bridge_c_top释放，C++侧分配的桥接内存只能调用freeCBridgeStruct释放，跨语言调用释放函数必然触发堆损坏。
• 数组存储顺序必须对齐：如果不需要保持跨语言索引语义，可以在C++侧直接按列优先顺序访问数组，省去2维及以上数组的转置拷贝开销。
• 不要手动修改结构体对齐：Intel Fortran的bind(C)默认对齐规则和MSVC extern "C"结构体在64位下默认8字节对齐完全一致，加pack属性反而会导致成员偏移错位。
• 不要直接映射Fortran数组描述符：虽然Intel公开了数组描述符结构，但不同编译选项、编译器版本下布局会变化，直接映射的代码升级编译器后大概率失效，可维护性极差。
• 字符编码统一用UTF-8：Qt侧统一用QString::fromUtf8/toUtf8做转换，Intel Fortran 2021及以上版本原生支持UTF-8字符kind，可避免多字节字符乱码。

内容的提问来源于stack exchange，提问作者CoderJoe1991