C++ 中整数向量的序列化/反序列化

Question

待完成任务

我正在尝试将整数向量序列化为字符串，以便可以将其存储到文件中。使用的方法是将整数逐字节复制到缓冲区中。为此，我使用了 std::copy_n 函数。

为了反序列化，我反向做了同样的事情，即将缓冲区中的字节逐字节复制到整数中，并将这些整数附加到向量中。

我不确定这是否是实现此目标的最佳/最快方法。

代码

序列化函数

char *serialize(vector <int> nums)
{
    char *buffer = (char *)malloc(sizeof(int)*nums.size());
    vector <int>::iterator i;
    int j;
    for(i = nums.begin(), j = 0; i != nums.end(); i++, j += 4) {
        copy_n(i, 4, buffer+j);
    }
    return buffer;
}

反序列化函数

vector <int> deserialize(char *str, int len)
{
    int num;
    vector <int> ret;
    for(int j = 0; j < len; j+=4) {
        copy_n(str+j, 4, &num);
        ret.push_back(num);
    }
    return ret;
}

任何关于如何改进这段代码的输入都会非常有帮助。我也很想知道实现相同目标的其他方法。

Answer 1

你的方法有很多问题。

char *serialize(vector <int> nums)
{
    char *buffer = (char *)malloc(sizeof(int)*nums.size());
    vector <int>::iterator i;
    int j;
    for(i = nums.begin(), j = 0; i != nums.end(); i++, j += 4) {
        copy_n(i, 4, buffer+j);
    }
    return buffer;
}

1）它手动分配内存，这是危险的并且很少必要。

2）它并没有像你想象的那样做。它从字面上复制每个int并尝试将其填充到char. 因此，如果任何值高于255（可填充到 a 中的最大数量char），则数据就会被损坏。

如果您正在寻找效率，那么我认为最好的方法是将数据直接写入输出流，而不是先将其转换为字符串。

请记住，像这样写出的二进制数据是不可移植的。我只会用它来序列化/反序列化本地数据。最好是单次会话。除此之外，您必须开始考虑使每个输出数据可移植，这会变得更加复杂。就我个人而言，除非绝对必要，否则我会完全避免使用二进制方法。

如果你必须这样做，我可能会做更多类似这样的事情：

template<typename POD>
std::ostream& serialize(std::ostream& os, std::vector<POD> const& v)
{
    // this only works on built in data types (PODs)
    static_assert(std::is_trivial<POD>::value && std::is_standard_layout<POD>::value,
        "Can only serialize POD types with this function");

    auto size = v.size();
    os.write(reinterpret_cast<char const*>(&size), sizeof(size));
    os.write(reinterpret_cast<char const*>(v.data()), v.size() * sizeof(POD));
    return os;
}

template<typename POD>
std::istream& deserialize(std::istream& is, std::vector<POD>& v)
{
    static_assert(std::is_trivial<POD>::value && std::is_standard_layout<POD>::value,
        "Can only deserialize POD types with this function");

    decltype(v.size()) size;
    is.read(reinterpret_cast<char*>(&size), sizeof(size));
    v.resize(size);
    is.read(reinterpret_cast<char*>(v.data()), v.size() * sizeof(POD));
    return is;
}

这些函数的接口遵循标准库中设置的约定，并且足够灵活，您可以使用它序列化为文件（使用std::fstream）或字符串（使用std::stringstream）。

std::vector<int> v = {1, 2, 3, 500, 900};

std::stringstream oss; // this could just as well be a `std::fstream` 

if(serialize(oss, v))
{
    std::vector<int> n;
    if(deserialize(oss, n))
    {
        for(auto i: n)
            std::cout << i << '\n';
    }
}

输出：

1
2
3
500
900