从 fstream 读取内容后，std::list 未正确初始化

Question

简单解释一下：使用<fstream> ，我将std::list实例写入.txt文件：

#include <fstream>
#include <list>

std::list<Item> list_1; //example list
list_1.push_back(Item(...));

std::ofstream file;
file.open("record.txt", std::ios::trunc);

if (file.is_open()) {
    file.write((char*)&list_1, sizeof(std::list<Item>)) << std::endl;

    file.close();
}

但是，当我从同一个文件中读取数据并将数据分配给std::list实例时：

file.open("record.txt", std::ios::in);
if (file.is_open()) {
    std::list<Item> list_1;
    file.read((char*)&list_1, sizeof(std::list<Item>));
}

当我尝试访问它的元素时，它给了我一个错误。 然而，这不是我的问题。 因为std::list存储指向该元素的指针，所以我必须手动存储元素，就像我在这里所做的那样：

for (auto const& item : list_1) {
    file << item.amount << std::endl;
    file << item.value << std::endl;
    file << item.item_name << std::endl;
    file << (char*)&item.type << std::endl;
}

然后我读了这些值。 使用这些值创建一个新的Item实例并将其存储在我的list 。 旁注：我可以从.txt文件访问list_1的size()属性，因为它是位于堆栈中的std::list<Item>的成员。 所以它被ofstream保存了。

for (int i = 0; i < list_1.size(); i++) {
    int amount = 0;
    int value = 0;
    std::string item_name;
    Item_Type type = item;

    file >> amount;
    file >> value;
    file >> item_name;
    file >> (char*)&type;

    Item item(amount, value, item_name, type);
    main_player_inv.push_back(item);

我希望这可以工作，因为现在std::list应该没有未初始化的成员，对吧？

好吧，它给了我这个错误：

this->_Mypair._Myval2._Myhead 是 0x228B4050240

这基本上意味着list_1->_Mypair._Myval2._Myhead是一个指向 memory 越界的指针。 问题是，与我可以手动保存值和初始化的元素指针不同，我无法访问list_1->_Mypair._Myval2._Myhead的数据或手动编辑它，因为它是私有成员。 或者，我没有办法在网上找到。

所以，我有两个问题：

• 我可以初始化list_1->_Mypair._Myval2._Myhead以使其指向有效的 memory 吗？

• 有没有办法更轻松地序列化std::list并检索它的内容？

如果这两个问题都无法回答，我想谈谈我正在尝试做的事情：

std::list<Item>用作字符或对象的清单。 在我的项目中，我想将player和容器等对象的项目存储在std::list<Item>实例中。 我认为这对于面向对象的 Player 结构来说是最合适的做法。 以下是一些类，例如：

播放器 class

class Player : public Object {
public:
    int level, experience;
    double health;
    float resistance; // 0.000 - 1.000
    std::list<Item> inventory;
public:
    Player() :
        level(0), experience(0), health(10.0), resistance(0.0f) {};
    Player(int x, int y, std::string obj_name, Obj_Type type, int level, int experience, double health, float resistence) :
        Object(x, y, obj_name, type), level(level), experience(experience), health(health), resistance(resistence) {};
};

项目 class

struct Item {
public:
    unsigned int amount, value;
    std::string item_name;
    Item_Type type;  // enum
public:
    Item() :
        amount(0), value(0), item_name("undefined"), type(item) {};
    Item(int amount, int value, std::string item_name, Item_Type type) :
        amount(amount), value(value), item_name(item_name), type(type) {};
};

如果您知道存储玩家物品的更好方法，物品是 class 实例； 或者完全知道一个更好的方法来做到这一点，请帮助我。

Answer 1

您无法读取/写入std::list object （或任何其他重要类型）的原始字节，因为您将写入/读取您不需要关心的原始指针和其他内部数据成员和。

正如您已经发现的那样，您必须（反）序列化您班级的各个数据成员。

我建议使用二进制格式而不是文本格式，例如：

#include <type_traits>

template <typename T, std::enable_if_t<std::is_scalar<T>::value, bool> = true>
void writeToStream(std::ostream &out, const T &value) {
    out.write(reinterpret_cast<const char*>(&value), sizeof(value));
}

template <typename T, std::enable_if_t<std::is_scalar<T>::value, bool> = true>
void readFromStream(std::istream &in, T &value) {
    in.read(reinterpret_cast<char*>(&value), sizeof(value));
}

void writeToStream(std::ostream &out, const std::string &value) {
    size_t size = value.size();
    writeToStream(out, size);
    out.write(value.c_str(), size);
}

void readFromStream(std::istream &in, std::string &value) {
    size_t size;
    readFromStream(in, size);
    value.resize(size);
    in.read(value.data() /* or: &value[0] */, size);
}

template <typename Container>
void writeToStream(std::ostream &out, const Container &items) {
    size_t count = items.size();
    writeToStream(out, count);
    for(const auto& item : items) {
        writeToStream(out, item);
    }
}

template <typename Container>
void readFromStream(std::istream &in, Container &items) {
    size_t count;
    readFromStream(in, count);
    items.reserve(count);
    for(size_t i = 0; i < count; ++i) {
        Container::value_type item;
        readFromStream(in, item);
        items.push_back(item);
    }
}

template<typename Container>
void writeToFile(const std::string &fileName, const Container &items) {
    std::ofstream file(fileName, std::ios::binary);
    file.exceptions(std::ofstream::failbit);
    writeToStream(file, items);
}

template<typename Container>
void readFromFile(const std::string &fileName, Container &items) {
    std::ifstream file(fileName, std::ios::binary);
    file.exceptions(std::ifstream::failbit);
    readFromStream(file, items);
}

struct Item {
public:
    unsigned int amount, value;
    std::string item_name;
    Item_Type type;  // enum
public:
    Item() :
        amount(0), value(0), item_name("undefined"), type(item) {};
    Item(int amount, int value, std::string item_name, Item_Type type) :
        amount(amount), value(value), item_name(item_name), type(type) {};

    void writeTo(std::ostream &out) const {
        writeToStream(out, amount);
        writeToStream(out, value);
        writeToStream(out, item_name);
        writeToStream(out, type);
    }

    void readFrom(std::istream &in) {
        readFromStream(in, amount);
        readFromStream(in, value);
        readFromStream(in, item_name);
        readFromStream(in, type);
    }
};

void writeToStream(std::ostream &out, const Item &item) {
    item.writeTo(out);
}

void readFromStream(std::istream &in, Item &item) {
    item.readFrom(in);
}

class Player : public Object {
public:
    int level, experience;
    double health;
    float resistance; // 0.000 - 1.000
    std::list<Item> inventory;
public:
    Player() :
        level(0), experience(0), health(10.0), resistance(0.0f) {};
    Player(int x, int y, std::string obj_name, Obj_Type type, int level, int experience, double health, float resistence) :
        Object(x, y, obj_name, type), level(level), experience(experience), health(health), resistance(resistence) {};

    void writeTo(std::ostream &out) const {
        writeToStream(out, level);
        writeToStream(out, experience);
        writeToStream(out, health);
        writeToStream(out, resistance);
        writeToStream(out, inventory);
    }

    void readFrom(std::istream &in) {
        readFromStream(in, level);
        readFromStream(in, experience);
        readFromStream(in, health);
        readFromStream(in, resistance);
        readFromStream(in, inventory);
    }
};

void writeToStream(std::ostream &out, const Player &player) {
    player.writeTo(out);
}

void readFromStream(std::istream &in, Player &player) {
    player.readFrom(in);
}

#include <fstream>
#include <list>

int main() {
    std::list<Item> list_1; //example list
    list_1.push_back(Item(...));

    writeToFile("record.txt", list_1);

    list_1.clear();

    readFromFile("record.txt", list_1);
    
    return 0;
}

如果您真的想要一个文本文件，请改用operator<<和operator>> ，在您的类中覆盖它们，例如：

（随意调整它以使用您想要的任何格式......）

#include <limits>

void discardLine(std::istream &in) {
    in.ignore(std::numeeric_limits<std::streamsize>::max(), '\n');
}

template<typename CharT, typename Traits>
void streamFailed(std::basic_ios<CharT,Traits> &stream) {
    stream.setstate(std::ios_base::failbit);
}

template <typename Container>
std::ostream& operator<<(std::ostream &out, const Container &items) {
    out << '[' << items.size() << '\n';
    for(const auto& item : items) {
        out << item << '\n';
    }
    out << ']\n';
    return out;
}

template <typename Container>
std::istream& operator>>(std::istream &in, Container &items) {
    char ch;
    in >> ch;
    if (ch != '[') {
        streamFailed(in);
    } else {
        size_t count;
        in >> count;
        discardLine(in);
        items.reserve(count);
        for(size_t i = 0; i < count; ++i) {
            Container::value_type item;
            in >> item;
            items.push_back(item);
        }
        in >> ch;
        if (ch != '[') {
            streamFailed(in);
        }
    }
}

template<typename Container>
void writeToFile(const std::string &fileName, const Container &items) {
    std::ofstream file(fileName, std::ios::binary);
    file.exceptions(std::ofstream::failbit);
    file << items;
}

template<typename Container>
void readFromFile(const std::string &fileName, Container &items) {
    std::ifstream file(fileName, std::ios::binary);
    file.exceptions(std::ifstream::failbit);
    file >> items;
}

struct Item {
public:
    unsigned int amount, value;
    std::string item_name;
    Item_Type type;  // enum
public:
    Item() :
        amount(0), value(0), item_name("undefined"), type(item) {};
    Item(int amount, int value, std::string item_name, Item_Type type) :
        amount(amount), value(value), item_name(item_name), type(type) {};

    friend std::ostream& operator<<(std::ostream &out, const Item &item) {
        out << '(' << item.amount << ' ' << item.value << ' ' << static_cast<int>(item.type) << ' ' << item.item_name << ')';
        return out;
    }

    friend std::istream& operator>>(std::istream &in, Item &item) {
        char ch;
        in >> ch;
        if (ch != '(') {
            streamFailed(in);
        } else {
            int itype;
            in >> item.amount >> item.value >> itype;
            item.type = static_cast<Item_Type>(itype);
            std::getline(in >> std::ws, item_name, ')');
        }
        return in;
    }
};

class Player : public Object {
public:
    int level, experience;
    double health;
    float resistance; // 0.000 - 1.000
    std::list<Item> inventory;
public:
    Player() :
        level(0), experience(0), health(10.0), resistance(0.0f) {};
    Player(int x, int y, std::string obj_name, Obj_Type type, int level, int experience, double health, float resistence) :
        Object(x, y, obj_name, type), level(level), experience(experience), health(health), resistance(resistence) {};

    friend std::ostream& operator<<(std::ostream &out, const Player &player) {
        out << '(' << level << ' ' << experience << ' ' health << ' ' << resistance << '\n';
        out << inventory;
        out << ')';
        return out;
    }

    friend std::istream& operator>>(std::istream &in, Player &player) {
        char ch;
        in >> ch;
        if (ch != '(') {
            streamFailed(in);
        } else {
            in >> player.level >> player.experience >> player.health >> player.resistance >> player.inventory;
            in >> ch;
            if (ch != ')') {
                streamFailed(in);
            }
        }
        return in;
    }
};

#include <fstream>
#include <list>

int main() {
    std::list<Item> list_1; //example list
    list_1.push_back(Item(...));

    writeToFile("record.txt", list_1);

    list_1.clear();

    readFromFile("record.txt", list_1);
    
    return 0;
}