C++ ifstream: how to open and read a file

A C++ ifstream, std::ifstream from <fstream>, is a stream that reads from a file. std::ifstream in("notes.txt"); opens the file, if (!in) tells you when that failed, and std::getline(in, line) in a loop reads it line by line. The file is closed automatically when the variable goes out of scope.

The whole program, reading a notes.txt of three lines saved in the folder you start the program from (the section on why a file does not open says which folder that is):

Call the bank
Buy coffee
Book the dentist

#include <fstream>
#include <iostream>
#include <string>

int main() {
    std::ifstream in("notes.txt");
    if (!in) {
        std::cerr << "could not open notes.txt\n";
        return 1;
    }
    std::string line;
    while (std::getline(in, line)) {
        std::cout << line << '\n';
    }
}

It printed those three lines, in order. Each std::getline call reads the next line into line, and the loop ends when none is left; C++ getline has the details of the call, Windows line endings included.

The samples are C++17, built with MSVC 19.44, Clang 19.1 (MSVC STL), GCC 16.2 and Clang 23.1 (libc++); all four printed the same unless a sentence says otherwise. One of them uses std::filesystem, which is C++17 (Since When’s C++17 table).

How do you check that the file opened?

Test the stream as soon as you create it: if (!in) is true when the file could not be opened. The constructor does not throw or stop the program when the open fails; it sets the stream’s failbit, its failed flag, and a failed stream reads nothing. This sample opens a file that does not exist:

std::ifstream in("missing.txt");
if (!in) {
    std::cout << "could not open missing.txt\n";
}
std::cout << std::boolalpha;
std::cout << "is_open: " << in.is_open() << '\n';  // false

std::string line;
int lines = 0;
while (std::getline(in, line)) {
    ++lines;
}
std::cout << "lines read: " << lines << '\n';      // 0

All four printed:

could not open missing.txt
is_open: false
lines read: 0

Without the check, a missing file reads like an empty one, and the program says nothing. if (!in) asks whether the stream has failed; in.is_open() asks whether it has a file attached, and right after the constructor the two agree.

How do you read words and numbers from a file?

Use >>, as you would with std::cin: in >> word reads one word, in >> name >> score reads a word and then a number, and a read in a loop’s condition goes on until the file ends. scores.txt holds a name and a score on each line:

Ana 90
Ben 72
Cy 90

std::ifstream in("scores.txt");
if (!in) {
    std::cerr << "could not open scores.txt\n";
    return 1;
}
std::string name;
int score = 0;
int total = 0;
while (in >> name >> score) {
    std::cout << name << ": " << score << '\n';
    total += score;
}
std::cout << "total: " << total << '\n';

All four printed:

Ana: 90
Ben: 72
Cy: 90
total: 252

The loop runs while both reads work and stops at the first one that fails, here at the end of the file. Reading with >> and then with std::getline from the same file meets a leftover newline: why getline seems skipped after >> explains it and gives both fixes.

How do you read a whole file into a string?

Send the file’s buffer into a std::ostringstream, from <sstream>, a stream that writes into a string in memory, and take the string from it:

std::ifstream in("notes.txt");
std::ostringstream buffer;
buffer << in.rdbuf();
std::string text = buffer.str();

std::cout << text;
std::cout << "size: " << text.size() << '\n';

All four printed:

Call the bank
Buy coffee
Book the dentist
size: 42

in.rdbuf() is the file’s stream buffer, and << copies all of it into buffer; text is then an ordinary std::string, newlines included. On an empty file, << inserted nothing and left buffer failed, with an empty string, on all four, and a file that did not open did the same. So check in with if (!in) right after opening it, and then test text, not buffer.

Do you need to call close()?

No: the stream’s destructor closes the file when the variable goes out of scope, at the closing brace of the block that declared it. Call close() to open another file with the same variable: in.close(); in.open("scores.txt"); read the second file on all four, even after the first had been read to its end and the stream had failed. Without the close(), open() on a stream that was still open failed on all four, and the next read got nothing.

Why does my file not open?

Usually because of the path. A relative path, a name such as "notes.txt" or "data/notes.txt" that does not start at the top of the disk, is looked for in the working directory: the folder the program was started from, by a terminal or an IDE, which need not be the folder that holds the program. Visual Studio, for one, starts the program in the project’s folder by default, not in the folder it builds the program into.

This sample writes data/notes.txt, inside a folder data in the working directory, and leaves no notes.txt beside it. try_open opens a path and says whether it worked:

void try_open(const std::string& path) {
    std::ifstream in(path);
    if (!in) {
        std::cout << path << ": not opened\n";
        return;
    }
    std::cout << path << ": opened\n";
}
// ...
try_open("notes.txt");       // looked for in the working directory
try_open("data/notes.txt");  // data is a folder in it

std::filesystem::current_path("data");  // change the working directory
try_open("notes.txt");                  // the same name, now found

All four printed:

notes.txt: not opened
data/notes.txt: opened
notes.txt: opened

The program did not move; only its working directory did, and the same "notes.txt" then opened. Called with no argument, std::filesystem::current_path() (C++17) returns the working directory, so printing it shows where your program is looking. So put the file in the working directory, start the program from the folder that holds the file, or write the path from the working directory, as "data/notes.txt" does.

If the path is right, check the name: the extension is part of it, so notes and notes.txt are two different names. In a string literal a backslash starts an escape sequence, so in "data\notes.txt" the \n is one character, a newline, and that name opened on none of the four: write "data/notes.txt", which opened on all four, or, on Windows only, double the backslash, "data\\notes.txt".

How do you write a file with std::ofstream?

std::ofstream is the mirror image: std::ofstream out("log.txt"); creates the file, or empties it if it exists, and out << ... writes to it as std::cout writes to the screen. Open it with std::ios::app to add to the end instead:

{
    std::ofstream out("log.txt");  // creates log.txt
    out << "started\n";
    out << "loaded 3 notes\n";
}                                  // closed here
show("written");

{
    std::ofstream out("log.txt", std::ios::app);
    out << "saved\n";              // added at the end
}
show("appended");

{
    std::ofstream out("log.txt");  // opened again: emptied
}
show("opened again");

Each show call reads log.txt back with a std::ifstream and prints its lines. All four printed:

written:
  started
  loaded 3 notes
  (2 lines)
appended:
  started
  loaded 3 notes
  saved
  (3 lines)
opened again:
  (0 lines)

Each pair of braces closes its stream, as the destructor runs, before show reads the file. The plain open in the last block emptied the file because an ofstream’s default mode acts as out | trunc, and trunc, truncate, empties the file as it opens.

An ifstream cheat sheet

Standard library has the answers on the library’s other types and functions.