将继承的类存储到文件的更好方法

Question

此代码有效，但正确的做法是什么？

我的意思是，如何消除 read_in 函数中的 switch 语句，或者处理动物类或其子类中的所有读取，以便我的 read_in 函数可以像我的 write_out 函数一样简单？

我有一个vector<animal*> *animals，里面装满了猫和普通动物，我需要在文件中写入/读取。

我省略了一些代码，所以帖子不会太大...

enum class animal_type
{
    GENERIC_ANIMAL,
    CAT
};

假设我有一个班级动物

class animal
{
    animal_type m_type;
    string m_name;

    virtual void write_binary(ofstream &out)
    {
        out.write((char*)(&m_type), sizeof(m_type)); //first 'animal_type'
        out.write((char*)(&m_type), sizeof(m_type)); //second 'animal_type'
        out.write(m_name.c_str(), m_name.size()+1);
    {

    virtual void read_binary(std::ifstream &in)
    {
        in.read((char*)(&m_type), sizeof(m_type)); //read the second animal type here
        m_name = read_null_string(in);//this function returns next string from input
    }
};

还有一个派生自动物的类

class cat : public animal
{
    bool m_is_cute;

    void write_binary(std::ofstream &out)
    {
        animal::write_binary(out);
        out.write((char*)(&m_is_cute), sizeof(m_is_cute));
    }

    void read_binary(std::ifstream &in)
    {
        animal::read_binary(in);
        in.read((char*)(&m_is_cute), sizeof(m_is_cute));

    }
 };

我将它们写入这样的文件

void write_out(std::ofstream &out, std::vector<animal*> *animals)
{
    int size = animals->size();
    out.write((char*)(&size), sizeof(size));

    for(animal* a : *animals)
    {
        a->write_binary(out);
    }
}

然后像这样从文件中读取它们

void read_in(std::ifstream &in, std::vector<animal*> *animals)
{
    animals->clear();
    int size;
    in.read((char*)(&size), sizeof(size));
    for(int i = 0; i< size; ++i)
    {
        animal_type type;
        //read the first 'animal_type' here
        in.read((char*)(&type), sizeof(type));
        animal *a;
        switch(type)
        {
            case(animal_type::GENERIC_ANIMAL):
            a = new animal(in);//this constructor just calls the read_binary method
            break;

            case(animal_type::CAT):
            a = new cat(in);//this constructor just calls the read_binary method
            break;
        }
        animals->push_back(a);
    }
}

Answer 1

这是（众多）选项之一：

首先，我们将enum class animal_type 更改为普通的旧枚举，因为我们想将其用作整数。如果不允许这样做，请将其保留为 enum class animal_type 并使用 static_cast<size_t> 稍后进行转换。

enum animal_type
{
    GENERIC_ANIMAL = 0, // must be 0. First index in array
    CAT,
    LAST, // must be last. Put no animals after it
    FIRST  = GENERIC_ANIMAL // makes it easy to loop FIRST to LAST
};

然后定义你所有的动物。

接下来，构建一个调用适当动物构造函数的函数数组。该数组必须与上面的枚举完全匹配。如果这是一个问题，请考虑改用std::map。

std::function<animal *(std::ifstream &)> animalFactory[] =
{
    [](std::ifstream & in) {return new animal(in);},
    [](std::ifstream & in) {return new cat(in);}
};

Documentation on std::function

Documentation on Lambda expressions

接下来定义发生坏事时要抛出的异常。可以很简单

class Bogus_File_Exception: public std::exception
{
    const char* what() const
    {
        return "File read failed.";
    }
};

终于read_in变成了

void read_in(std::ifstream &in, std::vector<animal*> & animals) // note the reference
{
    animals.clear();
    int size;
    if (in.read((char*)(&size), sizeof(size))) // testing for successful read
    {
        for(int i = 0; i< size; ++i)
        {
            animal_type type;
            if (in.read((char*)(&type), sizeof(type))) // testing again
            {
                if (type < animal_type::LAST)
                {
                    animals.push_back(animalFactory[type](in));
                }
                else
                {
                    throw Unknown_Animal_Exception();
                }
            }
            else
            {
                throw Bogus_File_Exception();
            }
        }
    }
    else
    {
        throw Bogus_File_Exception();
    }
}