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

我正在研究嵌入式设备(微控制器),我想将对象保存到永久存储器(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; 
};

解决方法:

您的保存和加载代码可能是合理的通用代码,并且在单独的“管理器”类中最有效,使每个数据类只负责将自身呈现为可重新加载：

// 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() ];
    }
};

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

然后每个函数应该按顺序序列化类的所有属性(链接基类并在需要时调用聚合对象上的序列化.)

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数据被序列化用于网络传输的方式,所以可能你可以利用库来做到这一点 – 即使你不这样做可以访问操作系统.

标签：c,arrays,serialization,bytearray,microcontroller
来源： https://codeday.me/bug/20190830/1768023.html