Opening, Defining and Closing a File

Programming Language & Its Applications — Virtual Functions and File Handling, NEC licence examination syllabus (Nepal Engineering Council).

Opening, Defining and Closing a File

C++ streams replace C's FILE* — and because they are objects, the destructor closes the file for you.

🌍 Where this lives: the difference between fopen and std::ifstream is RAII, and it eliminates a real bug class. A C file handle leaks if you return early or throw; a C++ stream cannot, because its destructor runs on every exit path. This is the same reason Python's with open(...) exists and why Java added try-with-resources in 2011 — three languages independently concluding that "remember to close it" is a losing strategy. Search "resource leak file descriptor exhaustion" to see what happens when a long-running server gets this wrong: it eventually fails with "Too many open files" and stops serving anyone.

The three stream classes

#include <fstream> std::ifstream INPUT file stream — reading std::ofstream OUTPUT file stream — writing std::fstream BOTH — read and write They inherit from the console-stream hierarchy, which is why everything you know about cin and cout works on files: ios_base │ ios / \ istream ostream │ \ / │ ifstream iostream ofstream │ fstream THREE WAYS TO OPEN: 1. constructor (preferred — RAII from the first line) std::ifstream in("data.txt"); 2. default construct, then open() std::ifstream in; in.open("data.txt"); 3. with explicit mode flags std::fstream f("data.dat", std::ios::in | std::ios::out | std::ios::binary); CLOSING: in.close(); /* explicit */ } /* or just let the destructor do it */ The destructor closes it. An explicit close() is needed only when you want to reopen the same object, or to check for write errors before the object dies.

The open-mode flags

std::ios::in open for reading std::ios::out open for writing std::ios::app APPEND — every write goes to the end std::ios::ate seek to the end ON OPEN (but you may then seek elsewhere and write there) std::ios::trunc TRUNCATE to zero length if it exists std::ios::binary no newline translation Combine with the bitwise OR: std::ios::out | std::ios::app DEFAULTS if you pass no mode: ifstream → in ofstream → out | trunc ← DESTROYS existing content fstream → in | out app vs ate — a real distinction: app : writes ALWAYS append, even if you seek elsewhere ate : position starts at the end, but you can seek and overwrite THE EQUIVALENT OF C's MODES: "r" → ifstream f(name) "w" → ofstream f(name) /* truncates */ "a" → ofstream f(name, ios::app) "r+" → fstream f(name, ios::in | ios::out) "w+" → fstream f(name, ios::in | ios::out | ios::trunc) "rb" → ifstream f(name, ios::binary)

open_close.cpp

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

int main() {
    /* WRITE — ofstream truncates by default */
    {
        std::ofstream out("marks.txt");
        if (!out) { std::cerr << "cannot open for writing\n";
                    return 1; }
        out << "101 Ram    87.5\n"
            << "102 Sita   91.0\n"
            << "103 Hari   76.5\n";
    }   /* destructor closes and flushes HERE */

    /* APPEND — does not destroy what is there */
    {
        std::ofstream out("marks.txt", std::ios::app);
        out << "104 Gita   68.0\n";
    }

    /* READ */
    {
        std::ifstream in("marks.txt");
        if (!in) { std::cerr << "cannot open for reading\n";
                   return 1; }
        std::string line;
        int n = 0;
        while (std::getline(in, line))
            std::cout << "  " << ++n << " | " << line << "\n";
        std::cout << "  read " << n << " lines\n";
    }

    /* a file that does not exist */
    std::ifstream missing("no_such_file.txt");
    std::cout << "  missing file: is_open=" << std::boolalpha
              << missing.is_open()
              << "  fail=" << missing.fail() << "\n";

    /* reopening the same object requires close() first */
    std::ifstream f("marks.txt");
    f.close();
    f.open("marks.txt");
    std::cout << "  reopened: " << f.is_open() << "\n";
    return 0;
}
Output:
  1 | 101 Ram    87.5
  2 | 102 Sita   91.0
  3 | 103 Hari   76.5
  4 | 104 Gita   68.0
  read 4 lines
  missing file: is_open=false  fail=true
  reopened: true

Checking that the open succeeded

FOUR EQUIVALENT TESTS, all common: std::ifstream in("data.txt"); if (!in) { /* failed */ } ← idiomatic if (in.fail()) { /* failed */ } if (!in.is_open()) { /* failed */ } if (!in.good()) { /* failed */ } Why `if (!in)` works: ifstream has explicit operator bool() const; which returns !fail(). It is marked explicit, so it converts in a CONDITION but not in arithmetic — the "safe bool idiom" from the data-conversion topic doing real work. if (in) ✔ contextual conversion int n = in; ✗ correctly rejected WHY A CHECK IS MANDATORY: An unchecked failed stream does not throw and does not crash. Every subsequent read silently fails, leaving your variables untouched: std::ifstream in("typo_in_filename.txt"); int x = 0; in >> x; /* fails silently */ std::cout << x; /* prints 0 — looks like real data */ That is how a missing file becomes "the marks are all zero" instead of an error message. Always check. FILENAME NOTE: the path is relative to the program's WORKING DIRECTORY, not the source file's location. "file not found" when the file is clearly there is nearly always this.

The silent-failure behaviour is the single most important practical point in this topic. C's fopen returns NULL, which crashes loudly the moment you use it — annoying but obvious. A failed C++ stream is a valid object that quietly does nothing, so the bug surfaces far from its cause. Check every open.

Worked example — a copy utility with real error handling

copy_util.cpp

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

/* returns bytes copied, or -1 on error */
long copyFile(const std::string &src, const std::string &dst) {
    std::ifstream in(src, std::ios::binary);
    if (!in) {
        std::cerr << "  cannot read " << src << "\n";
        return -1;
    }
    std::ofstream out(dst, std::ios::binary);
    if (!out) {
        std::cerr << "  cannot write " << dst << "\n";
        return -1;
    }

    /* stream-to-stream copy: one line, buffered */
    out << in.rdbuf();

    /* verify the WRITE succeeded — a full disk fails here,
       not at open time */
    out.flush();
    if (!out) { std::cerr << "  write failed\n"; return -1; }

    in.clear();
    in.seekg(0, std::ios::end);
    return static_cast<long>(in.tellg());
}

int main() {
    /* make a source file */
    { std::ofstream f("source.txt");
      f << "Nepal Engineering Council\n2026 licence exam\n"; }

    long n = copyFile("source.txt", "target.txt");
    std::cout << "  copied " << n << " bytes\n";

    { std::ifstream f("target.txt");
      std::string line;
      while (std::getline(f, line))
          std::cout << "  > " << line << "\n"; }

    /* failure path */
    if (copyFile("does_not_exist.txt", "x.txt") < 0)
        std::cout << "  handled the error cleanly\n";
    return 0;
}
Output:
  copied 44 bytes
  > Nepal Engineering Council
  > 2026 licence exam
  cannot read does_not_exist.txt
  handled the error cleanly

Counting the 44 bytes: "Nepal Engineering Council" Nepal(5) + space(1) + Engineering(11) + space(1) + Council(7) = 25 newline = 1 "2026 licence exam" 2026(4) + space(1) + licence(7) + space(1) + exam(4) = 17 newline = 1 total = 44 ✔ The size technique is worth keeping: seekg to the end, then tellg gives the byte count. Note the in.clear() before it — after `out << in.rdbuf()` the input stream has hit EOF and is in a fail state, and seekg on a failed stream is IGNORED. Forgetting clear() is why tellg sometimes returns −1. Also note `out << in.rdbuf()` — inserting a stream BUFFER copies the whole thing in one buffered operation. It is the shortest correct file copy in C++.

🌍 Go further: C++17 added <filesystem>, which finally gave the language portable file operations — fs::exists(), fs::file_size(), fs::copy(), directory iteration, and path manipulation that handles Windows backslashes correctly. Before it, every project rolled its own or used Boost. Search "C++17 filesystem library tutorial"; fs::file_size("x.txt") replaces the whole seekg/tellg dance above with one call, and fs::copy replaces the function.

💡 Exam angle: name the three stream classes (ifstream, ofstream, fstream) and the header <fstream>. The open-mode flags table is asked directly — particularly that ofstream truncates by default and that app forces every write to the end. Always show the if (!file) check; marks are lost for omitting it. Know that the destructor closes the file (RAII) and that close() is needed only to reopen. Distinguish app from ate.

Syllabus points

File streams; open/close

Create a free account to tick topics off, take notes as you read, watch the video lessons and get a day-by-day study plan built around your exam date.