std：：list 从 fstream 读取内容后无法正确初始化-解网

问：

简单解释一下：使用，我将一个实例写入文件：<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;
}

然后我读取这些值。使用这些值创建一个新实例并将其存储在 my .旁注：我可以从文件中访问的属性，因为它是堆栈中的成员。因此，它被 .Itemlistsize()list_1.txtstd::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._Myheadlist_1->_Mypair._Myval2._Myhead

所以，我有两个问题：

我可以初始化以使其指向有效的内存吗？list_1->_Mypair._Myval2._Myhead
有没有办法更轻松地序列化和检索其内容？std::list

如果这两个问题都无法回答，我想谈谈我想做什么：

用作角色或对象的物品栏。在我的项目中，我想将容器等项目和对象存储在实例中。我认为这是面向对象的 Player 结构最合适的做法。以下是一些类，例如：std::list<Item>playerstd::list<Item>

Player 类

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) {};
};

Item 类

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) {};
};

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

C++ C++11 fstream 标准列表

2赞 UnholySheep 9/24/2022

您使用的类都不是微不足道的类型，因此两者都是完全错误的。你需要编写一些实际的序列化和反序列化代码，你不能只是将字节转储到一个文件中file.write((char*)&list_1, sizeof(std::list<Item>))file.read((char*)&list_1, sizeof(std::list<Item>));

2赞 UnholySheep 9/24/2022

同样也是错误的，因为它不是以 null 结尾的字符串file << (char*)&item.type

0赞 BoP 9/24/2022

std::list<Item>只是列表头。s 都单独存储在堆上，也不包含在中。Itemsizeof(std::list<Item>)

1赞 Mooing Duck 9/24/2022

顶级域名;每当您使用 C 样式的强制转换、reinterpret_cast或const_cast时，它几乎总是一个错误。

0赞 user4581301 9/24/2022

list是一个链表，通过指针连接在一起的项链。当您使用指针时，地址（而不是地址处的数据）将写入流中。正如你所料，数据的地址是无用的。读回文件时，数据可能不在同一位置，或者根本不存在。如果数据仍然存在，那么让两个链表都认为他们拥有指向的项目并且可以对它做任何他们想做的事情是不安全的。write

答：

1赞 Remy Lebeau 9/24/2022 #1

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

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

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

#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;
}

上一个：清除终端问题python

下一个：如何在页面刷新时保留选定的 Bootstrap 选项卡？

std：：list 从 fstream 读取内容后无法正确初始化

std::list doesn't initialize correctly after it's content gets read from fstream

评论