When you've built a program with g++ and are running it as ./program.out or ./program.exe, the path of that exe file is the working directory. This is the default directory where text files will be saved, and the default directory it will look at to try to open files to load.

You can adjust the path using ../ to go back/up one folder or, if you have a subfolder like a "data" directory, you can use the folder's name FOLDERNAME/file.txt as a path.

You can open the text file output with a text editor like notepad or a code editor like VS Code. It's just plaintext!

Many file formats are just plain text files if you open them in Notepad. You can save your program's output to more than just .txt files as well - you could use .csv (comma separated value) files, or .html files, or other file types as well.

Just name your file a .csv or .html file when using the open function:

output.open( "data.html" );

And then output text that is formatted as the correct file type:

output << "<h1>Q1 Data</h1>" << endl;
output << "<p>This year we found that <strong>potatoes</strong>" << endl;
output << "solid well, outselling tomatoes.</p>" << endl;

Any file type that is a plaintext file can be built as well - .html files, .csv files, heck, even .cpp files. However, generally if you wanted to write a program to output a different file type, you'd use a library to properly convert the data.

Example: Outputting HTML data:

#include <fstream>
using namespace std;

int main()
{
  ofstream outputFile( "page.html" );
  outputFile << "<body>" << endl;
  outputFile << "<h1>This is a webpage</h1>" << endl;
  outputFile << "<p>Hello, world!</p>" << endl;
  outputFile << "</body>" << endl;
  outputFile.close();
}

Example: Outputting CSV data:

#include <fstream>
using namespace std;

int main()
{
  ofstream outputFile( "spreadsheet.csv" );
  outputFile << "COLUMN1,COLUMN2,COLUMN3" << endl;
  outputFile << "cell1,cell2,cell3" << endl; // row 1
  outputFile << "cell1,cell2,cell3" << endl; // row 2
  outputFile << "cell1,cell2,cell3" << endl; // row 3
  outputFile.close();
}

We will use the same library to get access to both ofstream and ifstream. Remember "File Stream" is what "fstream" stands for.

#include <fstream>

Remember that ofstream was the data type of the variable we'd create to open a text file and write data out. For input, we use ifstream, but we still can open a file in the same way:

ifstream inputFile;
inputFile.open( "save.txt" );

We can read contents from our input file stream similarly to how we would work with cin for the keyboard input. Reading in one word or piece of data at a time will use the input stream operator >>:

// Read from text file, save to playerExperience variable.
inputFile >> playerExperience;

And reading a whole line of text at a time will use getline:

getline( inputFile, playerName );

We still need to use the ignore() function when moving from a >> statement to a getline statement:

inputFile >> playerHp;
inputFile.ignore();
getline( inputFile, playerName );

And, we can close the file manually if we'd like:

inputFile.close();

The file itself is read from the left-to-right, top-to-bottom, similar to how you might think of a typewriter working. If we use >>, it will read the left word to the right word, and once it hits the end of a line it will return all the way to the left but one line down. If we use getline, it will start at the top line and move down one line at a time as it reads.

1. Player name
2. Player's experience points
3. Player's gold amount

When we're saving an file with ofstream we don't really have to worry about if the file already exists or not - if it doesn't exist, a new one will be created.

For reading a file with ifstream, however, if no file exists to read, then what? Well, we should check to see if opening the file failed, and if it did, perhaps we use some default values instead, or give an error and exit the program.

To check if the open process failed, we use an if statement:

ifstream input;
input.open( "userdata.txt" );
if ( input.fail() )
{
  cout << "ERROR: Could not find file!" << endl;
  return 2;
}

Reading chunks of data:

Let's say you have a file full of data to read in. For this example, the file will be a list of numbers that we want to add together. The file might look something like….

File: Data.txt

9 15 16 0 10 13 5 16 1 9 2 17 3 3 8

In our program, we want to read all the numbers, but to do this, we need to use a loop and read in one number at a time. We can keep a running total variable to keep adding data to the sum as we go. We can use a loop to continue reading while it is successful, using this as the condition: input >> readNumber. This will stop the loop once there's nothing else to read, and it updates the readNumber variable with the input each cycle.

Example:

ifstream input( "data.txt" );

int sum = 0;    // Sum variable
int readNumber; // Buffer to store what we read in

// Keep reading while it's possible
while ( input >> readNumber )
  {
    sum += readNumber;  // Add on to the sum

    // Output what we did
    cout << "Read number " << readNumber
         << ",\t sum is now " << sum << endl;
  }

cout << "FINAL SUM: " << sum << endl;

File output:

Read number 9,   sum is now 9
Read number 15,  sum is now 24
(... etc ...)
Read number 3,   sum is now 119
Read number 8,   sum is now 127
FINAL SUM: 127

Reading lines of data:

In other cases, maybe you're reading in text data from a file and want to read in a full line at a time. We can use a while loop with the getline() function as well to make sure we read each line of a text file:

Example:

ifstream input( "story.txt" );

string line;

while ( getline( input, line ) )
{
  cout << line << endl;
}

File output:

CHAPTER I.
Down the Rabbit-Hole

Alice was beginning to get very tired of sitting by her
sister on the bank, and of having nothing to do: once or
twice she had peeped into the book her sister was
reading, but it had no pictures or conversations in it,
"and what is the use of a book," thought Alice "without
pictures or conversations?"

There are different ways you can design a text file's save format so that you can more easily read it in later on. Let's go over some common techniques. You might also want to take note of these for use in our class projects.

A plaintext file is a file that just contains text, which can be opened in a program like notepad.

Reading in data from a file is one thing, but making sense of what was read in is another. Are you storing saved data from the last session of the program? Are you trying to parse data to crunch? How do you read that data in logically?

First, if your program is going to be saving output that will need to be read in and made sense of later on, how do you organize the data that's output? It's up to you to make sure to structure the output save data in a consistent and readable way.

Let's say two developers come up with different formats to store a video game save file:

File: Output save game file (FORMAT 1)

RachelsGame
5
1000
RegnierCenter

File: Output save game file (FORMAT 2)

SAVEGAME        RachelsGame
LEVEL           5
GOLD            1000
LOCATION        RegnierCenter

• For FORMAT 1, we would have to make sure to write our program so that it always saves and loads in the specific order: GAME-NAME, LEVEL, GOLD, LOCATION.
• For FORMAT 2, since labels are added, we could read in a label, then decide whether the next thing to load in is the GAME-NAME, LEVEL, GOLD, or LOCATION. However, the extra information ("SAVEGAME", "LEVEL", "GOLD", "LOCATION") adds extra storage space to savegame file, and that information is mostly just useful to the humans reading it.

If every save file from the program is formatted in the same way (FORMAT 1), then when reading the file we can make assumptions…

• First word: Save game name - store in gameFileName.
• Second word: Player's level - store in level.
• Third word: Player's gold - store in gold.
• Fourth word: Player's location - store in location.

…And so on. This could work, but we could also take advantage of those human-readable labels that were added into the file (FORMAT 2):

• Read firstWord.
• If firstWord is "SAVEGAME", then read the next word into gameFileName.
  • Else if firstWord is "LEVEL", then read the next word into level.
  • Else if firstWord is "GOLD", then read the next word into gold.
  • Else if firstWord is "LOCATION", then read the next word into location.

So, let's say we have our four variables for a save game:

When we go to save our game file, here is what both formats' save process would look like:

Example: Saving for FORMAT 1

// Save the game
ofstream output( "save.txt" );
output << gameFileName << endl;
output << level << endl;
output << gold << endl;
output << location << endl;

File output: Saved game file:

SAVEGAME MyGame
LEVEL    1
GOLD     10
LOCATION OCB

Example: Saving for FORMAT 2

// Save the game
ofstream output( "save.txt" );
output << "SAVEGAME " << gameFileName << endl;
output << "LEVEL    " << level << endl;
output << "GOLD     " << gold << endl;
output << "LOCATION " << location << endl;

File output: Saved game file:

SAVEGAME MyGame
LEVEL    1
GOLD     10
LOCATION OCB

Now, to load in each format, we would have to take a couple of different approaches.

Example: Loading for FORMAT 1

For this format, the savegame data would have to always be in the same order, so we know we also load the data in the same order.

// Load the game
string buffer;
ifstream input( "save.txt" );
input >> gameFileName;
input >> level;
input >> gold;
input >> location;

Example: Loading for FORMAT 2

This one has the helper labels so we read in the first word, investigate what it says, and based on that decide which variable we're loading into next.

string buffer;
ifstream input( "save.txt" );

while ( input >> buffer )
{
  if ( buffer == "SAVEGAME" )
    input >> gameFileName;

  else if ( buffer == "LEVEL" )
    input >> level;

  else if ( buffer == "GOLD" )
    input >> gold;

  else if ( buffer == "LOCATION" )
    input >> location;
}

If we stepped through this, buffer is always going to store one of the data labels, because after buffer is read, we immediately read the second item in the line of text. Once the second item is read, the next thing to be read will be the next label.

// Save the game
ofstream output( "save.txt" );
output << gameFileName << endl;
output << level << endl;
output << gold << endl;
output << location << endl;

// Save the game
ofstream output( "save.txt" );
output << "SAVEGAME " << gameFileName << endl;
output << "LEVEL    " << level << endl;
output << "GOLD     " << gold << endl;
output << "LOCATION " << location << endl;

string buffer;
ifstream input( "save.txt" );

while ( input >> buffer )
{
  if ( buffer == "SAVEGAME" )
    input >> gameFileName;

  else if ( buffer == "LEVEL" )
    input >> level;

  else if ( buffer == "GOLD" )
    input >> gold;

  else if ( buffer == "LOCATION" )
    input >> location;
}

// Load the game
string buffer;
ifstream input( "save.txt" );
input >> gameFileName;
input >> level;
input >> gold;
input >> location;