How To: Read and Write ASCII and Binary Files in C++

// Method to read a string from a binary file by reading a char at a time until we hit the null-terminator
static string readBinaryString()
{
	string tempString = "";
	char tempChar;
 
	do {
		// Read a single char worth of data from the file (i.e. 1 byte)
		infileBinary.read( (char*)&tempChar, 1 );
 
		// If the character we read isn't a null-terminator, add it onto the end of the string
		if (tempChar != '\0')
		{
			tempString += tempChar;
		}
 
	} while (tempChar != '\0'); // Keep trucking until we hit the null-character that signifies the end of the string
 
	// Return the string we've just built
	return tempString;
}

/***
Project: Reading and writing objects in ASCII and binary
Author : r3dux
Date   : 02/12/2013
Version: 0.1
***/
 
#include <iostream>
#include <fstream>
 
using namespace std;
 
class Test
{
public:
	// Member properties
	string name;
	int age;
	float heightInMetres;
	short lastThreeTestScores[3];
 
	// Static filestream objects
	static ofstream outfileASCII;
	static ifstream infileASCII;
 
	static ofstream outfileBinary;
	static ifstream infileBinary;
 
	// Method to write a record to the outfile
	void writeASCIIRecord()
	{
		if (outfileASCII)
		{
			// IMPORTANT: The single space character at the end of this is what it splits on
			outfileASCII << "Name: " << name << endl;
			outfileASCII << "Age: " << age  << endl;
			outfileASCII << "HeightInMetres: " << heightInMetres << endl;
			outfileASCII << "LastThreeTestScores: " << lastThreeTestScores[0] << " " << lastThreeTestScores[1] << " " << lastThreeTestScores[2] << endl << endl;
		}
		else
		{
			cout << "ASCII file not open for writing!" << endl;
		}
	}
 
	// Method to read a record from the infile in ASCII format
	void readASCIIRecord()
	{
		// If the file's open, then read it...
		if (infileASCII)
		{
			// Note: We throw away the humanReadablePrefix and split on the space between it
			// and our actual data
			string humanReadablePrefix;
			infileASCII >> humanReadablePrefix >> name;
			infileASCII >> humanReadablePrefix >> age;
			infileASCII >> humanReadablePrefix >> heightInMetres;
			infileASCII >> humanReadablePrefix >> lastThreeTestScores[0] >> lastThreeTestScores[1] >> lastThreeTestScores[2];
 
			// NOTE: If the line we read is empty it moves onto the next line so we don't need to read
			// the blank line we placed between records here. However, if you start mixing in getline()
			// calls this is no longer the case! For example, try reading JUST the name using:
			//
			//  getline(infileASCII, name);
			//
			// And read everything else with the >> operator as above. It gets the first name as
			// "Name: Alice" (which you'd expect it to), but then fails to get the second name.
			// I would imagine that this is to do with the file pointers not being updated consistently.
			// Take away: Don't mix extraction operators and getline - odd things happen.
		}
		else
		{
			cout << "File not open for reading!" << endl;
		}
	}
 
	// Method to write a record to file in binary format
	void writeBinaryRecord()
	{
		// IMPORTANT: Name must be null terminated so we can extract it from the binary file
		// Note: If using C++11, instead of using the trick of de-referencing the
		// reverse_iterator, we can instead call:
		//
		//      char lastChar = name.back();
		//
		if (!name.empty())
		{
			char lastChar = *name.rbegin();
 
			// Name string not null terminated? Make it null terminated.
			if (lastChar != '\0')
			{
				name += '\0';
			}
		}
		else // Name is empty, so...
		{
			name = "NoNameSet"; // ...specify a placeholder name...
			name += '\0';       // ...and add the null terminator.
		}
 
		if (outfileBinary)
		{
			// IMPORTANT: The single space character at the end of this is what it splits on
			outfileBinary.write( (char*)name.c_str()        , name.size()       ); // Note: We don't have to go name.size() * sizeof(char) here as a char is 1 byte!
			outfileBinary.write( (char*)&age                , sizeof(int)       );
			outfileBinary.write( (char*)&heightInMetres     , sizeof(float)     );
			outfileBinary.write( (char*)&lastThreeTestScores, sizeof(short) * 3 );
		}
		else
		{
			cout << "Binary file not open for writing!" << endl;
		}
	}
 
	// Method to read a string from a binary file by reading a char at a time until we hit the null-terminator
	static string readBinaryString()
	{
		string tempString = "";
		char tempChar;
 
		do {
			// Read a single char worth of data from the file (i.e. 1 byte)
			infileBinary.read( (char*)&tempChar, 1 );
 
			// If the character we read isn't a null-terminator, add it onto the end of the string
			if (tempChar != '\0')
			{
				tempString += tempChar;
			}
 
		} while (tempChar != '\0'); // Keep trucking until we hit the null-character that signifies the end of the string
 
		// Return the string we've just built
		return tempString;
	}
 
	// Method to read a record from the infile
	void readBinaryRecord()
	{
		// If our file is open for reading...
		if (infileBinary)
		{
			// We have to read strings in a special way as we don't know how their size
			name = readBinaryString();
 
			// ...but we do know the sizes (in bytes) of ints, floats and our array of 3 shorts.
			infileBinary.read( (char*)&age, sizeof(int) );
			infileBinary.read( (char*)&heightInMetres, sizeof(float) );
			infileBinary.read( (char*)&lastThreeTestScores, sizeof(short) * 3 );
		}
		else
		{
			cout << "Binary file not open for reading!" << endl;
		}
	}
 
	// Open and close the outfile for writing in ASCII
	static void openToWriteASCII()  {
		outfileASCII.open("testfileASCII.txt");
	}
	static void closeOutfileASCII() {
		outfileASCII.close();
	}
 
	// Open and close the infile for reading in ASCII
	static void openToReadASCII()  {
		infileASCII.open("testfileASCII.txt");
	}
	static void closeInfileASCII() {
		infileASCII.close();
	}
 
	// Open and close the outfile for writing in binary
	static void openToWriteBinary()  {
		outfileBinary.open("testfileBinary.bin", ios_base::binary);
	}
	static void closeOutfileBinary() {
		outfileBinary.close();
	}
 
	// Open and close the infile for reading binary
	static void openToReadBinary()  {
		infileBinary.open("testfileBinary.bin", ios_base::binary);
	}
	static void closeInfileBinary() {
		infileBinary.close();
	}
 
	// Method to dump the object properties to the screen
	void print()
	{
		cout << "Name                  : " << name << endl;
		cout << "Age                   : " << age  << endl;
		cout << "Height in Metres      : " << heightInMetres << endl;
		cout << "Last Three Test Scores: " << lastThreeTestScores[0] << "\t" << lastThreeTestScores[1] << "\t" << lastThreeTestScores[2] << endl  << endl;
	}
};
 
/*** IMPORTANT: We MUST instantiate the static objects declared in the class! ***/
ofstream Test::outfileASCII;
ifstream Test::infileASCII;
 
ofstream Test::outfileBinary;
ifstream Test::infileBinary;
 
int main()
{
	// Create two objects of our Test class
	Test test;
	test.name = "Alice";
	test.age  = 33;
	test.heightInMetres = 1.7f;
	test.lastThreeTestScores[0] = 123;
	test.lastThreeTestScores[1] = 456;
	test.lastThreeTestScores[2] = 789;
 
	Test test2;
	test2.name = "Bob";
	test2.age  = 66;
	test2.heightInMetres = 3.4f;
	test2.lastThreeTestScores[0] = 111;
	test2.lastThreeTestScores[1] = 222;
	test2.lastThreeTestScores[2] = 333;
 
	// Print out their details so we know what to expect
	cout << "BEFORE writing to file..." << endl;
	test.print();
	test2.print();
 
	// Open the outfile for writing, write the two objects to it and close the file to save it
	Test::openToWriteASCII();
	test.writeASCIIRecord();
	test2.writeASCIIRecord();
	Test::closeOutfileASCII();
 
	// Create two new objects and read a saved record into each object
	Test test3, test4;
	Test::openToReadASCII();
	test3.readASCIIRecord();
	test4.readASCIIRecord();
 
	// Display the records we just read back from the file to ensure the data is the same
	cout << "AFTER reading data back from ASCII file: " << endl;
	test3.print();
	test4.print();
 
	Test::closeInfileASCII(); // Close the input file now we're done with it
 
	// Write test3 and test4 objects in binary format
	cout << "Writing retrieved objects as binary..." << endl << endl;
	Test::openToWriteBinary();
	test3.writeBinaryRecord();
	test4.writeBinaryRecord();
	Test::closeOutfileBinary();
 
	// Read binary objects back in
	cout << "Reading binary data back into new objects..." << endl;
	Test test5, test6;
	Test::openToReadBinary();
	test5.readBinaryRecord();
	test6.readBinaryRecord();
	test5.print();
	test6.print();
 
	// Don't forget to close the file now we're done with it
	Test::closeInfileBinary();
 
	return 0;
}