Question

使用具有const 成员变量的对象保存和检索内容（到磁盘文件或从磁盘文件中检索内容）的方法是什么？
更具体地说，const成员要求在对象创建时进行初始化。因此，内容的检索必须在初始化程序之前（构造函数的{}之前）进行。如果我们不介意封装，则可以检索并创建带有参数的对象。如何通过保持数据隐藏来做所有事情？

编译器：C ++ 14或更高版本。

对象的实例化，填充内容并为下一个上下文存储。

    { //CODE BLOCK 1 : making of content and saving to a diskfile
        Abcd abcd(65535,256,25);
        //some operations on abcd
        //save to disk
        QFile abcdFile("abcd.lion");
        abcdFile.open(QFile::WriteOnly);
        abcd.serialize(abcdFile);
        abcdFile.close();
    }

从文件中获取后使用同一对象。

    { //CODE BLOCK 2 : loading from file and continue in another context
        QFile abcdFile("abcd.lion");
        abcdFile.open(QFile::ReadOnly);
        Abcd abcdNew(abcdFile);
        abcdFile.close();
        if(!abcdNew.isHealthy())
            printf("abcd from hdd is NOT Healthy :(\n");
        else
        {
            //doTheJob(abcdNew);
        }
    }

课程。

#include <QFile>
class Abcd
{
    const bool _healthy;//true if properly initialized
    //IMPORTANT: _healthy has to be the first member in the class.
    //this is to execute its initializer list first
protected:
    const long _rX;
    const long _rY;
          long _count;
public:
    Abcd(const long refX,
         const long refY,
         const long count) :
        _healthy(true),
        _rX(refX), _rY(refY),
        _count(count)
    {

    }
    Abcd(QFile &src) :
        _healthy(deserialize(src)),
        //Hack. Actually the initialization happened by this statement.
        //just keeping the below statements for the sake of syntactical correctness. :(
        _rX(_rX), _rY(_rY)
        //,_count(count)
    {

    }
    virtual
    ~Abcd()
    {

    }
    inline
    bool isHealthy()
    {
        return _healthy;
    }
    bool serialize(QFile &dest)
    {
        if(dest.write((char *)&_rY,sizeof(_rY))!=sizeof(_rY)) return false;
        if(dest.write((char *)&_rX,sizeof(_rX))!=sizeof(_rX)) return false;
        if(dest.write((char *)&_count,sizeof(_count))!=sizeof(_count)) return false;
        return true;
    }
private:
    bool deserialize(QFile &src)
    {
        if(src.read((char *)&_rY,sizeof(_rY))!=sizeof(_rY)) return false;
        if(src.read((char *)&_rX,sizeof(_rX))!=sizeof(_rX)) return false;
        if(src.read((char *)&_count,sizeof(_count))!=sizeof(_count)) return false;
        return true;
   }
};

请提出一个更好的方法。为此，我引入了“健康”状态成员作为班级声明中的第一位成员。同样在反序列化中，我通过将const变量转换为char *指针来欺骗编译器。

Answer 1

我的建议是使用该类的static成员函数从磁盘检索文件的内容，并在成功检索内容之后构造一个对象。

代替：

 Abcd(QFile &src) :

使用

static Abcd deserialize(QFile& src);

并将其实现为：

Abcd Abcd::deserialize(QFile& src)
{
   long rX;
   long rY;
   long count;

   if(src.read((char *)&rY, sizeof(rY)) != sizeof(rY)) throw false;
   if(src.read((char *)&rX, sizeof(rX)) != sizeof(rX)) throw false;
   if(src.read((char *)&count, sizeof(count)) != sizeof(count)) throw false;

   return Abcd(rX, rY, count):
}

PS 很奇怪，先保存_rY，然后再保存_rX。没有错，这很奇怪。

Answer 2

我的建议是将Abcd和序列化/反序列化的逻辑分为两类。

好处：

根据设计，没有字段MyRegularUserGroup作为对象总是有效的。
类_healthy仅执行一项工作。没有任何存储逻辑（单一责任）

一些提示：

自C ++ 17起，RVO是必需的
Abcd字段仅使对象不可复制/移动可分配（无法与容器等配合使用）。只需正确地使用const正确性以确保不变性即可。
不继承实现，仅继承接口：Abcd是最终的，没有虚拟方法-更好的性能。
遵循Cpp Core Guidelines

const

class Abcd final
{
public:
    Abcd(const long refX, const long refY, const long count)
        : _rX(refX)
        , _rY(refY)
        , _count(count)
    {
    }

    long GetRX() const
    {
        return _rX;
    }

    long GetRY() const
    {
        return _rY;
    }

    long GetCount() const
    {
        return _count;
    }

protected:
    long _rX;
    long _rY;
    long _count;
};

如何从文件加载const变量的内容？

2 个答案: