Question

我正在研究嵌入式设备（微控制器），我想将对象保存到永久存储器（EEPROM）。我能找到的大多数序列化解决方案都以某种方式使用文件系统，但我的目标没有文件系统。

因此我的问题是，如何将对象序列化为字节数组，以便之后可以将该字节数组保存到EEPROM中？

这是我想要做的一个例子：

class Person{
     //Constructor, getters and setters are omitted

    void save(){
         char buffer[sizeof(Person)]; 
         serialize(buffer);
         EEPROM::Save(buffer, sizeof(Person)); 
    }

    void load(){
         char buffer[sizeof(Person)]; 
         EEPROM::Load(buffer, sizeof(Person));
         deserialize(buffer);
    }

    void serialize(char* result){
        //?????
    }

    Person deserialize(char* buffer){
        //??????
    }

private:
    char* name;  
    int   age; 
    float weight; 
};

Answer 1

save和load的代码很可能具有合理的通用性，并且在单独的“经理”中效果最佳。 class，只保留每个数据类的责任，将自身呈现为可重新加载：

// Interface class
class Serializable
{
public:
    virtual size_t serialize_size() const = 0;
    virtual void serialize(char* dataOut) const = 0;
    virtual void deserialize(const char* dataIn) = 0;
};

// Load / save manager
class EEPromManager
{
public:
    void save( const Serializable& s )
    {
        char * data;
        size_t data_len;
        reserve_memory( data, data_len, s );
        s.serialize( data );
        EEPROM::Save( data , data_len );
        delete [] data;
    }

    void load( Serializable& s )
    {
        char * data;
        size_t data_len;
        reserve_memory( data, data_len, s );
        EEPROM::Load( data, data_len );
        s.deserialize( data );
        delete [] data;
    }

private:
    char* reserve_memory( char*& data, size_t& data_len, const Serializable& s )
    {
        return new char[ s.serialize_size() ];
    }
};

您打算序列化/反序列化的每个类都应该从一个接口继承，该接口要求这些函数的虚拟接口。请注意，您需要在此处进行自己的内存管理。我给出了一个简单的例子，但你可能想要一些更强大的东西。

然后每个函数应该按顺序序列化类的所有属性（如果需要，链接基类并在聚合对象上调用serialize。）

class Person : public Serializable
{
public:
    virtual size_t serialize_size() const
    {
        return SerializablePOD<char*>::serialize_size(name) +
               SerializablePOD<int>::serialize_size(age) +
               SerializablePOD<float>::serialize_size(weight);
    }

    virtual void serialize(char* dataOut) const
    {
        dataOut = SerializablePOD<char*>::serialize(dataOut, name);
        dataOut = SerializablePOD<int>::serialize(dataOut, age);
        dataOut = SerializablePOD<float>::serialize(dataOut, weight);
    }
    virtual void deserialize(const char* dataIn)
    {
        dataIn = SerializablePOD<char*>::deserialize(dataIn, name);
        dataIn = SerializablePOD<int>::deserialize(dataIn, age);
        dataIn = SerializablePOD<float>::deserialize(dataIn, weight);
    }

private:
    char* name;
    int   age;
    float weight;
};

您将受益于通用代码，以序列化/反序列化每个单独的类型，因此您不必使用代码来编写字符串的长度等。每个POD类型的序列化/反序列化：

template <typename POD>
class SerializablePOD
{
public:
    static size_t serialize_size(POD str)
    {
        return sizeof(POD);
    }
    static char* serialize( char* target, POD value )
    {
        return memcpy( target, &value, serialize_size(value) );
    }
    static const char* deserialize( const char* source, POD& target )
    {
        memcpy( &target, source, serialize_size(target) );
        return source + serialize_size(target);
    }
};

template<>
size_t SerializablePOD<char*>::serialize_size(char* str)
{
    return sizeof(size_t) + strlen(str);
}

template<>
const char* SerializablePOD<char*>::deserialize( const char* source, char*& target )
{
    size_t length;
    memcpy( &length, source, sizeof(size_t) );
    memcpy( &target, source + sizeof(size_t), length );
    return source + sizeof(size_t) + length;
}

顺便说一句，您可能还需要考虑如果在软件升级中更改对象的架构会发生什么。您保存的对象在重新加载时可能会损坏，除非您使用 - 例如 - 类版本标识符对此进行编码。

最后的想法：在微观层面上，你所做的事情在很多方面类似于POD数据被序列化用于网络传输的方式，所以可能你可以利用库来做到这一点 - 甚至如果您无法访问操作系统。

Answer 2

要将字符串保存为二进制文件，通常我们会保存其长度，然后保存其内容。要保存其他原始数据，我们可以简单地存储它们的二进制形式。因此，在您的情况下，您需要存储的是：

Length to name
char array of name
age
weight

所以串口代码是：

size_t buffer_size = sizeof(int) + strlen(name) + sizeof(age) + sizeof(weight);
char *buffer = new char[buffer_size];
*(int*)p = strlen(name);  p += sizeof(int);
memcpy(p, name, strlen(name));  p += strlen(name);
*(int*)p = age;  p += sizeof(int);
*(float*)p = weight;
EEPROM::Save(buffer, buffer_size);
delete[] buffer;

要从二进制缓冲区读取字符串，首先读取其长度，然后复制其数据。

在C ++中将对象序列化为字节数组

2 个答案: