如何实现无需原始指针返回二进制数据的通用方式？附C++类伪代码

针对你遇到的问题——需要返回外部提供的不可修改POD结构体，同时避免原始指针和void*的不安全转换——这里有几个实用的方案，兼顾类型安全、内存自动管理和通用性：

方案1：带自定义删除器的std::unique_ptr<void> #

这个方案保留了基类的多态性，同时用智能指针自动管理内存，避免泄漏，还不需要修改原始结构体：

#include <memory>

// 基类修改为返回带删除器的智能指针
class Parent { 
public: 
    virtual std::unique_ptr<void, void(*)(void*)> getData(size_t & size) = 0; 
};

class A : public Parent { 
public: 
    std::unique_ptr<void, void(*)(void*)> getData(size_t & size) override {
        size = sizeof(structA);
        structA* a = new structA();
        // 填充结构体数据...
        
        // 返回时绑定对应类型的删除器，确保正确释放内存
        return {a, [](void* ptr) { delete static_cast<structA*>(ptr); }};
    }
};

class B : public Parent { 
public: 
    std::unique_ptr<void, void(*)(void*)> getData(size_t & size) override {
        size = sizeof(structB);
        structB* b = new structB();
        // 填充结构体数据...
        
        return {b, [](void* ptr) { delete static_cast<structB*>(ptr); }};
    }
};

优点： #

• 完全保留原有的多态结构，调用方无需知道具体子类类型
• 智能指针自动释放内存，彻底杜绝内存泄漏
• 不需要修改外部提供的structA/structB

缺点： #

• 调用方拿到void*后仍需转换回原始类型才能访问结构体成员（可结合其他方案优化）

方案2：使用std::variant实现类型安全的变体返回 #

如果你的场景中所有可能的结构体类型是已知的（仅structA和structB），可以用std::variant替代void*，实现完全的类型安全：

#include <memory>
#include <variant>

// 定义包含所有可能类型的变体
using DataVariant = std::variant<std::unique_ptr<structA>, std::unique_ptr<structB>>;

class Parent { 
public: 
    virtual DataVariant getData() = 0; 
};

class A : public Parent { 
public: 
    DataVariant getData() override {
        auto a = std::make_unique<structA>();
        // 填充结构体数据...
        return a;
    }
};

class B : public Parent { 
public: 
    DataVariant getData() override {
        auto b = std::make_unique<structB>();
        // 填充结构体数据...
        return b;
    }
};

使用示例： #

调用方可以通过std::visit安全地处理不同类型的数据：

void processData(DataVariant& var) {
    std::visit([](auto&& ptr) {
        // ptr会自动推导为对应类型的智能指针，无需强制转换
        if constexpr (std::is_same_v<decltype(ptr), std::unique_ptr<structA>&>) {
            // 处理structA的逻辑
        } else {
            // 处理structB的逻辑
        }
    }, var);
}

优点： #

• 完全类型安全，避免了void*强制转换的风险
• 内存自动管理，无需手动释放
• 调用方可以通过std::visit优雅地分支处理不同类型

缺点： #

• 需要提前知晓所有可能的结构体类型，后续新增类型需修改DataVariant定义

方案3：序列化到std::vector<uint8_t>返回二进制数据 #

如果调用方只需要二进制数据（无需直接访问结构体成员），可以把POD结构体序列化到std::vector<uint8_t>中，完全避免指针：

#include <vector>
#include <cstring>

class Parent { 
public: 
    virtual std::vector<uint8_t> getData() = 0; 
};

class A : public Parent { 
public: 
    std::vector<uint8_t> getData() override {
        structA a{};
        // 填充结构体数据...
        
        std::vector<uint8_t> buffer(sizeof(a));
        std::memcpy(buffer.data(), &a, sizeof(a));
        return buffer;
    }
};

class B : public Parent { 
public: 
    std::vector<uint8_t> getData() override {
        structB b{};
        // 填充结构体数据...
        
        std::vector<uint8_t> buffer(sizeof(b));
        std::memcpy(buffer.data(), &b, sizeof(b));
        return buffer;
    }
};

反序列化示例： #

如果后续需要恢复结构体：

structA restoreA(const std::vector<uint8_t>& buffer) {
    structA a{};
    std::memcpy(&a, buffer.data(), sizeof(a));
    return a;
}

优点： #

• 完全不需要指针，内存由std::vector自动管理
• 二进制数据可直接用于存储、网络传输等场景
• 调用方无需关心具体类型（仅需二进制流时）

缺点： #

• 若需访问结构体成员，需额外执行反序列化步骤
• 仅适用于POD类型（你的场景正好符合）

总结选择建议： #

• 需保留多态性且兼容未知类型：选方案1
• 所有类型已知且追求类型安全：选方案2
• 仅需二进制流用于存储/传输：选方案3

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