如何实现C结构体与含虚拟继承的C++类间高效互转？

问题背景 #

需要实现一个extern "C"导出函数作为C层与C++模板函数的Wrapper，要求：

• 不得修改现有C结构体、C++类及模板函数
• 尽可能减少数据拷贝
• 因C类采用菱形虚拟继承结构，无法直接强制转换C结构体指针与C类指针
• 避免依赖RTTI的dynamic_cast

现有代码结构 #

导出的C接口函数 #

extern "C" __declspec(dllexport) PEParserHandle* __cdecl openFile(PEParserHandle* ppEParserHandle) noexcept {
   
   openFile<>(/*pointer to Cpp class*/);
   return &ppEParserHandle; // 注：原代码此处存在错误，应返回ppEParserHandle而非其地址
};

C++模板函数 #

template<class PEParserBaseImpl>
inline PEParserBaseImpl& openFile(PEParserBaseImpl* pPEParserBaseImpl) noexcept {
   // 无关逻辑省略
   return *pPEParserBaseImpl;
};

C结构体定义 #

typedef struct PEParserFunctionExecutionLog {
    bool failed;
    union alignas(__int64) {
        // 无关成员省略
    } code;
} *pPEParserFunctionExecutionLog;

typedef struct PEParserSignatur {
    // 无关成员省略
} *pPEParserSignatur;

typedef struct PEParser
{
    unsigned int PEParserStructurType;
    union {
        PEParserFunctionExecutionLog pEParserFunctionExecutionLog;
        PEParserSignatur pEParserSignatur;
    }Dummy;
} *pPEParser;

typedef struct PEParserHandle
{
    pPEParser ppEParser;        
    // 无关成员省略
} *pPEParserHandle;

typedef struct PEParserHeader
{
    // 无关成员省略
} *pPEParserHeader;

typedef struct PEParserCombined
{
    PEParser pEParser;
    PEParserHandle pEParserHandle;
    PEParserHeader pEParserHeader;
    // 整合所有相关数据的结构体
} *pPEParserCombined;

C++类定义 #

typedef struct functionExecutionLog {
    bool failed;
    union alignas(__int64) {
        // 无关成员省略
    } code;
} PEParserfunctionExecutionLog;

typedef struct signatur {
    // 无关成员省略
} PEParsersignatur;

struct PEParserBase :
    virtual public functionExecutionLog,
    virtual public signatur 
{
    // 无关成员省略
};

typedef struct PEHEADER : 
    virtual public functionExecutionLog,
    virtual public signatur 
{
    // 无关成员省略
} PEParserHeader;

struct PEParser : 
    public PEParserBase, 
    public PEParserHeader
{
    // 整合所有相关数据的类
};

核心问题 #

C层传递的PEParserHandle*需要转换为C模板函数接受的PEParserBaseImpl*（即CPEParser*），但菱形虚拟继承导致内存布局复杂，直接强制转换存在安全风险，且无法修改原有结构。

具体实现方案 #

方案一：内存布局兼容+偏移计算 #

利用C结构体与C++类的成员兼容性（同名同类型成员），通过偏移计算实现指针转换，需在编译期验证布局一致性：

1. 编写辅助转换工具

#include <cstddef> // 用于offsetof

// 辅助转换类：关联C结构体与对应C++类
template<typename CppClass, typename CStruct>
struct StructToClassBridge {
    static CppClass* convert(CStruct* c_struct_ptr) noexcept {
        // 从PEParser成员指针反推PEParserCombined起始地址
        PEParserCombined* combined = reinterpret_cast<PEParserCombined*>(
            reinterpret_cast<char*>(c_struct_ptr) - offsetof(PEParserCombined, pEParser)
        );
        // 转换为C++类指针（依赖布局一致）
        return reinterpret_cast<CppClass*>(combined);
    }
};

2. 编译期断言验证布局

// 验证基础结构的大小与成员偏移一致
static_assert(sizeof(PEParserFunctionExecutionLog) == sizeof(functionExecutionLog), 
              "C与C++执行日志结构大小不匹配");
static_assert(offsetof(PEParserFunctionExecutionLog, failed) == offsetof(functionExecutionLog, failed), 
              "执行日志中failed成员偏移不匹配");
static_assert(sizeof(PEParserSignatur) == sizeof(signatur), 
              "C与C++签名结构大小不匹配");
static_assert(sizeof(PEParserCombined) == sizeof(PEParser), 
              "C整合结构体与C++类大小不匹配");

3. 修改导出函数

extern "C" __declspec(dllexport) PEParserHandle* __cdecl openFile(PEParserHandle* ppEParserHandle) noexcept {
    // 将C结构体指针转换为C++类指针
    PEParser* cpp_pe_parser = StructToClassBridge<PEParser, PEParser>::convert(ppEParserHandle->ppEParser);
    
    // 调用C++模板函数
    openFile<PEParser>(cpp_pe_parser);
    
    // 返回原C层指针
    return ppEParserHandle;
};

方案二：中间Wrapper类（类型擦除） #

通过创建继承自C基类的Wrapper类，持有C结构体指针，避免直接指针转换，适合原C类包含虚函数的场景：

1. 实现Wrapper类

class PEParserWrapper : public PEParserBase {
private:
    PEParserHandle* m_c_handle;
public:
    explicit PEParserWrapper(PEParserHandle* handle) noexcept : m_c_handle(handle) {}
    
    // 重写PEParserBase中的虚函数，内部映射到C结构体数据
    // 示例：如果PEParserBase有获取失败状态的虚函数
    bool isFailed() const noexcept override {
        return m_c_handle->ppEParser->Dummy.pEParserFunctionExecutionLog->failed;
    }
    
    // 按需重写其他虚函数...
};

2. 修改导出函数

extern "C" __declspec(dllexport) PEParserHandle* __cdecl openFile(PEParserHandle* ppEParserHandle) noexcept {
    // 创建Wrapper对象（若模板函数需持久化修改，可改为堆分配）
    PEParserWrapper wrapper(ppEParserHandle);
    // 调用模板函数
    openFile<PEParserWrapper>(&wrapper);
    
    return ppEParserHandle;
};

替代思路 #

• 全局哈希表映射：维护std::unordered_map<PEParserHandle*, PEParser*>，将C结构体指针与C++对象指针关联，需处理线程安全与内存释放问题，适合小体量场景。
• 扩展C结构体（若允许）：在PEParserHandle中添加void* cpp_object成员，直接存储C++对象指针，但不符合“不修改现有C结构体”的要求。

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