Question

我正在一个项目中，我必须编写一个包含其他三个类作为私有成员变量的类到二进制文件，然后可以在其中将其读回到要在代码中使用的变量。该代码将写入文件，但是我不知道它是否在写入正确的信息，就像我尝试读取文件读取的文件一样。我已经包括了当前的设置，看起来正确吗？如果是这样，可能是哪里出了问题，如果没有，我该如何解决？

如果您需要我添加任何其他代码，请询问。另一个考虑因素是用作玩家对象的成员函数的两个类是从其他类继承的。

    if (cFile.is_open())
    {
        cFile.seekp(ios::beg);
        for (int i = 0; i < 3; i++)
        {
            cFile.write(reinterpret_cast<char *>(&players[i]), sizeof(Character));
        }

        cFile.seekg(ios::beg);
        for (int i = 0; i < 3; i++)
        {
            cFile.read(reinterpret_cast<char *>(&playersRead[i]), sizeof(Character));
            playersRead[i].display();
        }

        cFile.close();
    }
    else
    {
        cout << "Error opening file." << endl;
    }

我已经在这段代码上工作了几天，确实遇到了麻烦。感谢您能获得的任何帮助。

#pragma once
#include <iostream>
using std::ostream;
#include "string.h"
#include "coinPouch.h"
#include "backpack.h"

class Character
{
public:
	Character();
	Character(String name);
	Character(String name, CoinPouch wallet, Backpack storage);
	Character(const Character & copy);
	~Character();
	Character & operator =(const Character & rhs);

	friend ostream & operator << (ostream & out, const Character & c);

	void purchase(int p, int g, int s, int c);
	void income(int p, int g, int s, int c);
	void addPotion(const Potion & toAdd);
	void checkBalance();
	void checkBackpack();
	void changeName(const String & newN);
	void display();

	String getName();
	CoinPouch getWallet();
	Backpack getStorage();
	void setName(String name);
	void setWallet(CoinPouch wallet);
	void setStorage(Backpack storage);

private:
	String m_name;
	CoinPouch m_wallet;
	Backpack m_storage;

};

#include "character.h"
using std::endl;
using std::cout;

Character::Character() : m_name("Player")
{
	CoinPouch initialW;
	Backpack initialS;
	m_wallet = initialW;
	m_storage = initialS;
}

Character::Character(String name) : m_name(name)
{
	CoinPouch initialW;
	Backpack initialS;
	m_wallet = initialW;
	m_storage = initialS;
}

Character::Character(String name, CoinPouch wallet, Backpack storage) : m_name(name), m_wallet(wallet), m_storage(storage)
{

}

Character::Character(const Character & copy) : m_name(copy.m_name), m_wallet(copy.m_wallet), m_storage(copy.m_storage)
{

}

Character::~Character()
{

}

Character & Character::operator =(const Character & rhs)
{
	if (this != &rhs)
	{
		m_name = rhs.m_name;
		m_wallet = rhs.m_wallet;
		m_storage = rhs.m_storage;
	}

	return *this;
}

ostream & operator << (ostream & out, const Character & c)
{
	out << c.m_name << ": " << endl;
	out << c.m_wallet << endl;
	out << c.m_storage << endl;
	
	return out;
}

void Character::purchase(int p, int g, int s, int c)
{
	m_wallet.buy(p, g, s, c);
}

void Character::income(int p, int g, int s, int c)
{
	m_wallet.add(p, g, s, c);
}

void Character::addPotion(const Potion & toAdd)
{
	m_storage.addPotion(toAdd);
}

void Character::checkBalance()
{
	m_wallet.display();
}

void Character::checkBackpack()
{
	m_storage.displayContents();
}

void Character::changeName(const String & newN)
{
	m_name = newN;
}

void Character::display()
{
	cout << m_name << ": " << endl;
	m_wallet.display();
	m_storage.displayContents();
}

String Character::getName()
{
	return m_name;
}

CoinPouch Character::getWallet()
{
	return m_wallet;
}

Backpack Character::getStorage()
{
	return m_storage;
}

void Character::setName(String name)
{
	m_name = name;
}

void Character::setWallet(CoinPouch wallet)
{
	m_wallet = wallet;
}

void Character::setStorage(Backpack storage)
{
	m_storage = storage;
}

#pragma once
#include <iostream>
using std::ostream;
#include "string.h"

class CoinPouch
{
public:
	CoinPouch();
	CoinPouch(String init);
	CoinPouch(int p, int g, int s, int c);
	CoinPouch(const CoinPouch & copy);
	~CoinPouch();
	CoinPouch & operator = (const CoinPouch & rhs);
	friend ostream & operator << (ostream & out, const CoinPouch & c);
	
	void add(int p, int g, int s, int c);
	bool checkCost(int p, int g, int s, int c);
	void buy(int p, int g, int s, int c);
	void convertCost();
	void roundUp();
	void display();

	int getP();
	int getG();
	int getS();
	int getC();

private:
	String m_amount;

	int m_platinum;
	int m_gold;
	int m_silver;
	int m_copper;
};

#pragma once
#include "potions.h"

class DynamicArray
{
public:
	// Constructors
	DynamicArray();
	~DynamicArray();
	DynamicArray(const DynamicArray & copy);

	// Op Equals
	DynamicArray & operator =(const DynamicArray & rhs);

	// Insert, delete, and get elements functions
	int getElements();
	void Insert(const Potion & add);
	void Delete(const Potion & rmv);
	void display();

	// Overloaded operators
	Potion & operator [](int index);
	friend ostream & operator << (ostream & out, const DynamicArray & d);

private:
	// Member variables
	Potion * m_array;
	int m_elements;

	// Find function
	int Find(const Potion & target);
};

#pragma once
#include "string.h"
#include <iostream>
using std::ostream;

class Potion
{
public:
	// Constructors
	Potion();
	Potion(String name, String description, String potency, String cost);
	Potion & operator = (const Potion & rhs);
	Potion(const Potion & copy);

	// Desctructor
	~Potion();

	// Overloaded operators
	bool operator == (const Potion & rhs) const;
	friend ostream & operator << (ostream & out, const Potion & p);

	// Getter functions
	String getName();
	String getDesc();
	String getPotency();
	String getCost();
	int getP();
	int getG();
	int getS(); 
	int getC();

	// Setter functions
	void setName(String name);
	void setDesc(String desc);
	void setPotency(String potency);
	void setCost(String cost);

	// Convert and display functions
	void convertCost();
	void display();

private:
	// Strings to hold item information
	String m_name;
	String m_description;
	String m_potency;
	String m_cost;

	// Ints to hold cost information
	int m_platinum;
	int m_gold;
	int m_silver;
	int m_copper;

	// Logical test
	bool m_isnull = false;
};

#pragma once
#include <iostream>
using std::ostream;

class String
{
public:
	// Constructors
	String();
	String(char ch);
	String(const char * str);

	// Destructor
	~String();

	// Copy Constructor and Copy Assignment Constructor
	String(const String & copy);
	String & operator=(const String & rhs);
	friend ostream & operator << (ostream & out, const String & s);

	// Added Functionality
	void display();
	void upper();
	void lower();

	// Operator Conversion
	operator char *();
	operator const char *();

	// Overloaded operator
	bool operator == (const String & rhs) const;

private:
	// Member variables
	char * m_str;
	int m_ischar;

};

#pragma once
#include "dynamicarray.h"
#include "coinPouch.h"
#include "string.h"

class Backpack
{
public:
	Backpack();
	Backpack(DynamicArray potions);
	Backpack(const Backpack & copy);
	~Backpack();
	Backpack & operator = (const Backpack & rhs);
	friend ostream & operator << (ostream & out, const Backpack & c);

	void addPotion(const Potion & add);
	void usePotion(const Potion & rm);
	void displayContents();

private:
	DynamicArray m_potions;

	int m_number;
};

这是一个学校项目，我应该将Character类写入二进制文件以保存字符，以便在程序启动时将其加载。现在，我只是在尝试确保可以成功地将它们写入二进制文件或从二进制文件中读取文件，因此我很幸运。

糟糕，我不知道要发布什么，也不想将所有内容发布到文件中。这是角色类。让我知道还需要什么。

Answer 1

应该立即显而易见，该代码无法正常工作。

        cFile.write(reinterpret_cast<char *>(&players[i]), sizeof(Character));

无论sizeof(Character)有多大，我们可以有一个Character和一个m_name占用更多字节。因此，此代码不可能写出角色的名称，显然需要这样做。

在向文件中写入任何内容之前，请确定（最好是记录）字节级别的文件格式。确保您的代码以记录的格式编写，并且还可以以记录的格式读取。跳过此步骤会导致痛苦，并且也使调试变得不可能，因为您无法查看文件并将其与规范进行比较以查看编写器或读取器是否有错。

如果您记录了播放器名称将在文件中占用的字节，您将立即意识到您需要具有可变长度的对象并以某种方式对长度进行编码，或者选择最大大小的名称并分配这些字节。但是，由于您跳过了这一至关重要的步骤，因此您实际上并没有想出如何将Character写入文件。

如何将类中的类写入/读取到二进制文件C ++

1 个答案: