std::variant运行时序列化与反序列化实现求助

我希望实现一个Serialization类，用于将变量序列化到文件或缓冲区。在为该类实现std::variant<T...>的序列化与反序列化时遇到了困难——我了解到无法在运行时获取variant的类型，相关操作需在编译时完成，但我需要将其持久化到文件。以下是我的代码：

class Serialization
{
private:
    std::vector<char> buffer;
public:
    inline std::size_t size()const{return buffer.size();};
    Serialization()=default;
    template<typename T>
    Serialization& operator<<(const T& val){
        static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable");
        const auto size = buffer.size();
        buffer.resize(buffer.size()+sizeof(T));
        std::memcpy(buffer.data() + size, static_cast<const void*>(&val), sizeof(T));
        return *this;
    }
    template<typename T>
    Serialization& operator>>(T& val){       
        static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable");            
        std::memcpy(&val, buffer.data(), sizeof(T));
        buffer.erase(buffer.begin(), buffer.begin() + sizeof(T));
        return *this;
    }        
    template<typename T>
    Serialization& operator<<(const std::vector<T>& val) {
        const auto size = val.size();
        *this << size;
        for(const auto& elem : val){
            *this << elem;
        }
        return *this;
    }
    template<typename T>
    Serialization& operator>>(std::vector<T>& val) {
        size_t size;
        *this >> size;
        val.resize(size);
        for(auto& elem : val){
            *this >> elem;
        }
        return *this;
    }
    template< class... Types >
    Serialization& operator<<(const std::variant<Types...>& val) {
        const std::size_t index = val.index();
        *this << index;
        std::visit([&](const auto& value){
            *this << value;
        }, val);
        return *this;
    }
    template< class... Types >
    Serialization& operator>>(std::variant<Types...>& val) {
        std::size_t index;
        *this >> index;
        if (index >= sizeof...(Types)) {
            throw std::out_of_range("Variant index out of range");
        }
        using value_type = std::variant_alternative_t<index, std::variant<Types...>>;
        //auto value = expand_type<Types...>(index);
        value_type value;
        *this >> value;
        val.emplace<index>(std::move(value));
        return *this;
    }
    //I also try this one
    template <typename... Ts>
    [[nodiscard]] std::variant<Ts...>
    expand_type(std::size_t i)
    {
        assert(i < sizeof...(Ts));
        static constexpr std::variant<Ts...> table[] = { Ts{ }... };
        return table[i];
    }
    friend std::ostream & operator << (std::ostream &out, const Serialization &s);
    friend std::istream & operator >> (std::istream &in,  Serialization &s);
    ~Serialization()=default;
};
template<>
Serialization& Serialization::operator<<(const std::string& val){
    const auto size = val.size();
    *this << size;
    buffer.insert(buffer.end(), val.begin(), val.end());
    return *this;
}
template<>
Serialization& Serialization::operator>>(std::string& val) {
    size_t size;
    *this >> size;
    val.resize(size);        
    std::memcpy(&val[0], buffer.data(), size);
    buffer.erase(buffer.begin(), buffer.begin() +size);
    return *this;
}
std::ostream & operator << (std::ostream &out, const Serialization &s){   
    out.write(s.buffer.data(),s.buffer.size());
    return out;
}    
std::istream & operator >> (std::istream &in,  Serialization &s){
    in.seekg(0, std::ios::end);
    s.buffer.resize(in.tellg());
    in.seekg(0, std::ios::beg);
    in.read(s.buffer.data(), s.buffer.size());
    return in;
}

问题分析 #

核心问题出在std::variant的反序列化函数中：从缓冲区读取的index是运行时变量，但std::variant_alternative_t要求模板参数必须是编译期常量，因此代码中using value_type = std::variant_alternative_t<index, std::variant<Types...>>;这一行无法通过编译。

解决方案 #

我们可以借助编译期索引序列，遍历std::variant的所有可能类型，根据运行时的index选择对应的类型进行反序列化。以下是修正后的反序列化实现：

template<class... Types>
Serialization& operator>>(std::variant<Types...>& val) {
    std::size_t index;
    *this >> index;
    if (index >= sizeof...(Types)) {
        throw std::out_of_range("Variant index out of range");
    }

    // 借助编译期索引序列处理运行时index
    auto deserialize_impl = [&]<std::size_t... Is>(std::index_sequence<Is...>) {
        using Func = void(Serialization::*)(std::variant<Types...>&);
        // 为每个类型生成对应的反序列化函数
        constexpr Func funcs[] = {
            [](Serialization& self, std::variant<Types...>& var) {
                typename std::variant_alternative_t<Is, std::variant<Types...>> value;
                self >> value;
                var.emplace<Is>(std::move(value));
            }...
        };
        // 根据运行时index调用对应函数
        (this->*funcs[index])(val);
    };

    deserialize_impl(std::index_sequence_for<Types...>{});
    return *this;
}

说明 #

1. 编译期索引序列：std::index_sequence_for<Types...>生成一个包含0到sizeof...(Types)-1的编译期索引序列，覆盖std::variant的所有可能类型。
2. 函数数组：通过折叠表达式生成一个函数数组，每个元素对应一个类型的反序列化逻辑，将对应类型从缓冲区读取后，emplace到variant中。
3. 运行时分发：根据读取到的index，调用数组中对应的函数，完成反序列化。

这个方案既满足了编译期类型推导的要求，又能处理运行时的index值，完美解决std::variant反序列化的核心问题。

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