Input/Output Operations on Files

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

Input/Output Operations on Files

The same << and >> you use on cout, plus getline, read/write, and random access with seekg.

🌍 Where this lives: everything your programs will ever persist goes through these operations. A CSV export from a report, a save-game file, an application log, a configuration file — all of them are one of the four patterns below. And the text-versus-binary choice you are about to make is the same one behind JSON versus Protocol Buffers in modern systems: human-readable and portable, or compact and fast. Search "JSON vs protobuf tradeoffs" once you have read the comparison here; you will find the same arguments about parsing cost and portability, at a much larger scale.

The four I/O styles

1. FORMATTED — operator<< and operator>> out << 101 << " " << "Ram" << " " << 87.5 << "\n"; in >> roll >> name >> marks; · converts between text and numbers · >> SKIPS whitespace and STOPS at whitespace · returns the stream, so it chains 2. LINE-ORIENTED — getline std::getline(in, line); /* to '\n' */ std::getline(in, field, ','); /* to a comma */ · reads whitespace INCLUDING spaces · the delimiter is consumed but NOT stored 3. CHARACTER — get and put char c; while (in.get(c)) out.put(c); int c; while ((c = in.get()) != EOF) ... 4. BLOCK / BINARY — read and write out.write(reinterpret_cast<const char*>(&obj), sizeof obj); in.read (reinterpret_cast<char*>(&obj), sizeof obj); · raw bytes, no conversion · both take char* — hence the cast · in.gcount() reports how many bytes were actually read THE >> vs getline TRAP: int n; std::string line; in >> n; /* reads 42, leaves '\n' */ std::getline(in, line); /* reads the EMPTY rest of that line! */ FIX: in >> n; in.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); std::getline(in, line); This is the single most common file-I/O bug in C++, and it is the exact analogue of C's leftover-newline scanf problem.

four_styles.cpp

#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <limits>

int main() {
    /* build a test file */
    { std::ofstream f("data.txt");
      f << "101 Ram Bahadur 87.5\n"
        << "102 Sita Devi 91.0\n"; }

    /* 1. FORMATTED — note >> stops at each space, so a
          two-word name needs TWO reads */
    {
        std::ifstream in("data.txt");
        int roll; std::string first, last; double m;
        while (in >> roll >> first >> last >> m)
            std::cout << "  formatted: " << roll << " ["
                      << first << " " << last << "] " << m << "\n";
    }

    /* 2. LINE — reads spaces, so the whole record arrives */
    {
        std::ifstream in("data.txt");
        std::string line;
        while (std::getline(in, line))
            std::cout << "  getline  : [" << line << "]\n";
    }

    /* the >> then getline trap, demonstrated and fixed */
    {
        std::istringstream s("42\nsome text here\n");
        int n; std::string rest;
        s >> n;
        std::getline(s, rest);
        std::cout << "  BROKEN: n=" << n
                  << " rest=[" << rest << "]\n";
    }
    {
        std::istringstream s("42\nsome text here\n");
        int n; std::string rest;
        s >> n;
        s.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
        std::getline(s, rest);
        std::cout << "  FIXED : n=" << n
                  << " rest=[" << rest << "]\n";
    }

    /* 3. CHARACTER — count what is there */
    {
        std::ifstream in("data.txt");
        long chars = 0, lines = 0, digits = 0;
        char c;
        while (in.get(c)) {
            chars++;
            if (c == '\n') lines++;
            if (c >= '0' && c <= '9') digits++;
        }
        std::cout << "  chars=" << chars << " lines=" << lines
                  << " digits=" << digits << "\n";
    }
    return 0;
}
Output:
  formatted: 101 [Ram Bahadur] 87.5
  formatted: 102 [Sita Devi] 91
  getline  : [101 Ram Bahadur 87.5]
  getline  : [102 Sita Devi 91.0]
  BROKEN: n=42 rest=[]
  FIXED : n=42 rest=[some text here]
  chars=40 lines=2 digits=12

The BROKEN/FIXED pair is the lesson. After `s >> n` read "42", the newline is still sitting in the buffer. getline sees it immediately, treats it as an empty line, and returns "". ignore(max, '\n') discards everything up to and including the next newline, so getline then reads the real line. Verifying the character counts for data.txt: line 1 "101 Ram Bahadur 87.5" = 20 chars + newline = 21 101(3) sp(1) Ram(3) sp(1) Bahadur(7) sp(1) 87.5(4) = 20 line 2 "102 Sita Devi 91.0" = 18 chars + newline = 19 102(3) sp(1) Sita(4) sp(1) Devi(4) sp(1) 91.0(4) = 18 chars = 21 + 19 = 40 ✔ lines = 2 ✔ digits: line 1 → 1,0,1,8,7,5 = 6 line 2 → 1,0,2,9,1,0 = 6 total = 12 ✔ The technique is the standard "count characters, words and lines" exam program: get(c) in a while loop, classify each character as you go. One pass, O(n), constant memory.

Binary I/O with objects

binary_io.cpp

#include <iostream>
#include <fstream>
#include <cstring>

/* A binary-writable record must be "plain old data":
   fixed-size members, NO std::string, NO pointers, NO
   virtual functions. A std::string member holds a POINTER
   to heap data — writing its bytes saves the pointer, not
   the text, and reading it back gives a dangling pointer. */
struct Student {
    int   roll;
    char  name[24];        /* fixed array, NOT std::string */
    float marks;
};

int main() {
    Student out[3] = {
        {101, "", 87.5f}, {102, "", 91.0f}, {103, "", 76.5f}
    };
    std::strcpy(out[0].name, "Ram Bahadur");
    std::strcpy(out[1].name, "Sita Devi");
    std::strcpy(out[2].name, "Hari Prasad");

    std::cout << "  sizeof(Student) = " << sizeof(Student) << "\n";

    /* WRITE all three in one call */
    {
        std::ofstream f("students.dat", std::ios::binary);
        f.write(reinterpret_cast<const char*>(out),
                3 * sizeof(Student));
    }

    /* READ them back */
    {
        std::ifstream f("students.dat", std::ios::binary);
        Student in[3];
        f.read(reinterpret_cast<char*>(in), 3 * sizeof(Student));
        std::cout << "  gcount = " << f.gcount() << " bytes\n";
        for (const auto &s : in)
            std::cout << "  " << s.roll << " " << s.name
                      << " " << s.marks << "\n";
    }

    /* file size -> record count */
    {
        std::ifstream f("students.dat", std::ios::binary);
        f.seekg(0, std::ios::end);
        long bytes = static_cast<long>(f.tellg());
        std::cout << "  file " << bytes << " bytes = "
                  << bytes / (long)sizeof(Student) << " records\n";
    }
    return 0;
}
Output:
  sizeof(Student) = 32
  gcount = 96 bytes
  101 Ram Bahadur 87.5
  102 Sita Devi 91
  103 Hari Prasad 76.5
  file 96 bytes = 3 records

Working out sizeof(Student) = 32: int roll 4 bytes offset 0 char name[24] 24 bytes offset 4 float marks 4 bytes offset 28 total = 32, and 32 is already a multiple of 4 (the largest alignment), so NO padding is needed. 3 records × 32 = 96 bytes ✔ matches gcount and tellg. WHY std::string CANNOT be written binary: A std::string is typically 32 bytes containing a pointer, a length, and a small-string buffer. write() saves those 32 bytes — including a heap ADDRESS from this run of this program. Read it back later and that address means nothing: you get garbage or a crash. For text data in a binary file, use a fixed char array (as here) or write the length followed by the characters: size_t n = s.size(); f.write((char*)&n, sizeof n); f.write(s.data(), n); TEXT vs BINARY, the practical comparison: size : text ~66 bytes here vs binary 96 — binary is LARGER for short records (fixed-width padding) but smaller for numeric data (a double is 8 bytes binary, up to 24 characters as text) speed : binary needs no parsing at all random access: binary gives O(1) via record × sizeof portability : text works everywhere; binary depends on endianness, padding, and sizeof(int) debuggable : text can be read with `cat`, grepped, diffed

The portability caveat is real, not pedantic. A binary file written by this program on a 64-bit x86 machine may be unreadable by the same source compiled for a different architecture, because padding rules and byte order differ. That is exactly why every real interchange format — JSON, XML, Protocol Buffers, SQLite — specifies its byte layout explicitly instead of dumping structs.

Random access — seekg, seekp, tellg, tellp

Every stream has a position indicator. Input and output streams have separate ones: seekg / tellg GET position (reading) seekp / tellp PUT position (writing) f.seekg(offset, direction); std::ios::beg from the beginning std::ios::cur from the current position std::ios::end from the end (offset usually ≤ 0) THE RECORD FORMULA, identical to C's: byte offset of record n = n × sizeof(Record) f.seekg(3 * sizeof(Student), std::ios::beg); /* record 3 */ f.seekg(-(long)sizeof(Student), std::ios::end); /* last */ f.seekg(0, std::ios::end); size = f.tellg(); /* size */ UPDATE IN PLACE — the payoff of fixed-size records: std::fstream f("students.dat", std::ios::in | std::ios::out | std::ios::binary); f.seekp(n * sizeof(Student), std::ios::beg); f.write(reinterpret_cast<const char*>(&rec), sizeof rec); That overwrites exactly those bytes. Changing one record in a 1 GB file touches 32 bytes. GOTCHA: after reading to EOF the stream is in a fail state and seekg is IGNORED. Call f.clear() first: f.clear(); f.seekg(0);

random_access.cpp

#include <iostream>
#include <fstream>
#include <cstring>

struct Student { int roll; char name[24]; float marks; };

int main() {
    /* create 5 records */
    {
        std::ofstream f("db.dat", std::ios::binary);
        const char *names[] = {"Ram","Sita","Hari","Gita","Bikash"};
        for (int i = 0; i < 5; i++) {
            Student s{101+i, "", 60.0f + i*7};
            std::strncpy(s.name, names[i], sizeof s.name - 1);
            f.write(reinterpret_cast<const char*>(&s), sizeof s);
        }
    }

    std::fstream f("db.dat", std::ios::in | std::ios::out
                             | std::ios::binary);
    const long SZ = sizeof(Student);

    /* jump straight to record 3 */
    Student s;
    f.seekg(3 * SZ, std::ios::beg);
    f.read(reinterpret_cast<char*>(&s), SZ);
    std::cout << "  rec 3: " << s.roll << " " << s.name
              << " " << s.marks
              << "  (tellg now " << f.tellg() << ")\n";

    /* modify it in place */
    s.marks += 10.0f;
    f.seekp(3 * SZ, std::ios::beg);
    f.write(reinterpret_cast<const char*>(&s), SZ);
    f.flush();

    f.seekg(3 * SZ, std::ios::beg);
    f.read(reinterpret_cast<char*>(&s), SZ);
    std::cout << "  rec 3 after +10: " << s.marks << "\n";

    /* the LAST record, via SEEK_END */
    f.seekg(-SZ, std::ios::end);
    f.read(reinterpret_cast<char*>(&s), SZ);
    std::cout << "  last  : " << s.roll << " " << s.name << "\n";

    /* backwards traversal — impossible without seeking */
    f.clear();
    f.seekg(0, std::ios::end);
    long count = static_cast<long>(f.tellg()) / SZ;
    std::cout << "  reverse: ";
    for (long i = count - 1; i >= 0; i--) {
        f.seekg(i * SZ, std::ios::beg);
        f.read(reinterpret_cast<char*>(&s), SZ);
        std::cout << s.roll << " ";
    }
    std::cout << "\n";
    return 0;
}
Output:
  rec 3: 104 Gita 81  (tellg now 128)
  rec 3 after +10: 91
  last  : 105 Bikash
  reverse: 105 104 103 102 101

Checking the arithmetic: sizeof(Student) = 32 record 3 starts at 3 × 32 = 96 after reading 32 bytes, tellg = 96 + 32 = 128 ✔ marks for i=3: 60.0 + 3×7 = 81 ✔ after +10: 91 ✔ last record: seekg(−32, end) = byte 128, record 4, roll 101+4 = 105 ✔ count = 160 / 32 = 5 records ✔ Cost comparison for reaching record 4 of 5: sequential: 5 reads, 160 bytes seek : 1 seek, 32 bytes For a million records that is 1,000,000 reads versus 1.

🌍 Go further: the fixed-record file you just built is a database table, and adding one more piece — an index mapping keys to byte offsets — turns O(n) lookup into O(log n). That is the entire concept behind CREATE INDEX. If you want to see it done properly, SQLite is a single readable C file that implements exactly this: fixed-size pages, a B-tree index, and seek-based access. Search "SQLite file format documentation" — it is unusually well written, and recognising your own seekg(n * sizeof(Record)) inside a real database engine is a genuinely satisfying moment.

💡 Exam angle: name the four I/O styles and when each is right. The >>-then-getline leftover-newline trap and its ignore() fix is asked directly. For binary I/O, know that read/write take char* (hence the cast), that gcount() reports bytes read, and that a std::string member cannot be written binary. The record offset formula n × sizeof(Record) with seekg/tellg is a guaranteed numerical — practise beg, cur and negative end offsets.

Syllabus points

Reading & writing files in C++

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.