class Serializable{public:  virtual void write( std::ostream &os) {}  virtual void read( std::istream &is) {}}class X : public Serializable{public:  virtual void write( std::ostream &os) {    Serializable::write( os );    os << x << ... << ...;  }  virtual void read( std::istream &is) {    Seializable::read( is );    is >> x  >> ... >> ...;  }private:  int x;  ...  ...}

class File{...  void read( Serializable *x )  {    x->read( /* your private fstream here */ );  }}

File f;Header header;Index index;f.read( &header );f.read( &index );f.close();

// Don't use namespace std in headers! Your cpp files will be like// "OH GOD I CANNOT UNUSE IT". Also, don't forget inclusion guards.#ifndef ROM_H#define ROM_H#include <vector>#include <string>const int KILOBYTE = 1024;struct ROMBank {  char data[8 * KILOBYTE];};struct RAMBank {  char data[8 * KILOBYTE];};struct VROMBank {  char data[16 * KILOBYTE];};class Rom {  std::vector<ROMBank> program_data;  std::vector<VROMBank> video_data;  std::vector<RAMBank> writable_data;  std::string name;  // and definitely don't remember an overall file length! Useless here.  // Stuff that we'll need to remember if we want to write out the file again.  char config[4];  public:  // Use RAII: initialize in constructor.  // The vectors will automatically deallocate, so we don't need any .close()  // or whatever. (The actual file on disk will close at the end of the ctor.)  Rom(const std::string& filename);  // Read-only access to program and video data.  // These might need more complicated logic, depending on how mapping works...  const ROMBank& ROM(int which) const { return program_data[which]; }  const VROMBank& VROM(int which) const { return video_data[which]; }  // Read-write access to writable data.  const RAMBank& RAM(int which) const { return writable_data[which]; }  RAMBank& RAM(int which) { return writable_data[which]; }  // TODO: Fix the destructor so it writes out the data back to the original  // file. Left as an exercise. This implements "battery-backed RAM".  ~Rom() {}};#endif

#include <fstream>#include "Rom.h"using namespace std;// I'm going to make a helper function to read values.template <typename T>T readValue(istream& is) {  T result;  // Note the new-style casting.  is.read(reinterpret_cast<char*>(&result), sizeof(T));  return result;}template <typename T>void readArray(istream& is, T* begin, int count) {  is.read(reinterpret_cast<char*>(begin), sizeof(T) * count);}Rom::Rom(const string& filename) : name(filename) {  // Use initialization lists where possible, as shown.  // We create the stream locally.  ifstream ifs;  // Unfortunately, the standard library doesn't use RAII very well in the  // case of file streams, so we have to do a little wrapping:  ifs.exceptions(ifstream::eofbit | ifstream::failbit | ifstream::badbit);  ifs.open(filename.c_str());  // Now, if anything goes wrong with the loading, an exception will be thrown.  // Although we have to do that manually for testing the header :)  // For now, we will reject "raw" dumps without a header.  if (readValue<int>(ifs) != 0x1A53454E) {    throw ifstream::failure("not an iNes ROM");  }  // Set up our rom pages.  program_data.resize(readValue<char>(ifs));  video_data.resize(readValue<char>(ifs));      char config[4];  readArray<char>(ifs, config, 4);  // To interpret that data, we make *member functions* that rearrange the bits  // and report an appropriate value.  // e.g.  // bool ROM::isVerticallyMapped() { return config[0] & 0x01; }  // But we should ONLY do that for things that calling code will care about.  // (Or at least, make the others private.)  // The calling code should NOT have to check what the "mapping" is in order  // to get at data; the file loading and/or access functions should apply  // the mapping.  // Check that there are 6 zero bytes.  const int padding = 6;  char reserved[padding];  readArray<char>(ifs, reserved, padding);  for (int i = 0; i < padding; ++i) {    if (reserved) {      throw ifstream::failure("not an iNes ROM");    }  }  // FIXME: Also check for required zero bits in the other four bytes.  // THEN, read the whole rest of the file and store "pages" in the vectors.  // Use the config information to apply whatever part of the "mapping" work  // makes sense at this point.}