Stream Class Hierarchy for Console I/O

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

Stream Class Hierarchy for Console I/O

Why cout, a file and a string all accept the same << — one inheritance tree, four destinations.

🌍 Where this lives: this hierarchy is the reason a function you write as void print(std::ostream& os) works unchanged whether it prints to the screen, writes a file, builds a string, or feeds a network socket. That is polymorphism paying for itself in a library you use every day — and it is the direct application of the virtual functions from earlier in this section. It is also why unit-testing output is easy in C++: pass a std::ostringstream instead of cout and assert on the resulting string. Search "dependency injection ostream testing"; this one design choice makes output testable without touching the filesystem.

The hierarchy

ios_base │ basic_ios ← state bits, locale / \ basic_istream basic_ostream / \ / \ / \ / \ ifstream basic_iostream ofstream istringstream / \ ostringstream / \ fstream stringstream CONCRETE CLASSES you actually use: HEADER CLASS DESTINATION <iostream> istream/ostream the console <fstream> ifstream a file, reading ofstream a file, writing fstream a file, both <sstream> istringstream a string, reading ostringstream a string, writing stringstream a string, both `std::ostream` is really `std::basic_ostream<char>`. There is a parallel wchar_t family (wcout, wofstream) for wide characters — same tree, different character type. That is what "basic_" means: a template over the character type. THE PAYOFF — one function, every destination: void printReport(std::ostream &os, const Data &d) { os << "Total: " << d.total << "\n"; } printReport(std::cout, d); /* screen */ printReport(fileStream, d); /* file */ printReport(stringStream, d); /* string */ os is a REFERENCE to the base, and << is resolved polymorphically through the stream buffer. Write the function once, use it everywhere.

The four predefined console streams

std::cin istream standard input (buffered) std::cout ostream standard output (buffered) std::cerr ostream standard error (UNBUFFERED) std::clog ostream standard log (buffered) cerr vs cout — the distinction that matters: cerr is UNBUFFERED (unitbuf is set), so output appears IMMEDIATELY. If the program crashes, your error message has already been written. cout may still be sitting in a buffer and be lost. cerr and cout are also SEPARATE channels at the OS level: ./prog > out.txt /* only cout redirected */ ./prog 2> err.txt /* only cerr redirected */ ./prog > out.txt 2>&1 /* both to the same file */ That separation is why you can pipe a program's data output while still seeing its errors on screen. cin and cout are TIED: any read from cin automatically flushes cout first. That is why std::cout << "Enter name: "; /* no endl */ std::cin >> name; shows the prompt before waiting. Without the tie the prompt could stay buffered and the program would appear to hang. std::cin.tie(nullptr); /* breaks the tie — a common competitive-programming speed trick, and a source of missing prompts */

streams.cpp

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

struct Student { int roll; std::string name; double marks; };

/* ONE function, works with ANY ostream */
void printTable(std::ostream &os,
                const std::vector<Student> &v) {
    os << "Roll  Name            Marks\n"
       << "-----------------------------\n";
    double total = 0;
    for (const auto &s : v) {
        os << s.roll << "   " << s.name;
        for (size_t i = s.name.size(); i < 16; i++) os << ' ';
        os << s.marks << "\n";
        total += s.marks;
    }
    os << "average: " << total / v.size() << "\n";
}

int main() {
    std::vector<Student> v = {
        {101, "Ram Bahadur", 87.5},
        {102, "Sita Devi",   91.0},
        {103, "Hari Prasad", 76.5}
    };

    /* destination 1: the console */
    std::cout << "--- to cout ---\n";
    printTable(std::cout, v);

    /* destination 2: a file — same function */
    { std::ofstream f("report.txt");
      printTable(f, v); }
    std::cout << "--- written to report.txt ---\n";

    /* destination 3: a string — same function */
    std::ostringstream ss;
    printTable(ss, v);
    std::string captured = ss.str();
    std::cout << "--- captured " << captured.size()
              << " chars into a std::string ---\n";

    /* cerr is unbuffered and a separate channel */
    std::cerr << "this goes to standard error\n";

    /* istringstream: parse FROM a string */
    std::istringstream in("104 Gita 68.0");
    Student g;
    in >> g.roll >> g.name >> g.marks;
    std::cout << "parsed from a string: " << g.roll << " "
              << g.name << " " << g.marks << "\n";
    return 0;
}
Output:
--- to cout ---
Roll  Name            Marks
-----------------------------
101   Ram Bahadur     87.5
102   Sita Devi       91
103   Hari Prasad     76.5
average: 85
--- written to report.txt ---
--- captured 149 chars into a std::string ---
this goes to standard error
parsed from a string: 104 Gita 68

Checking the average: (87.5 + 91.0 + 76.5) / 3 = 255.0 / 3 = 85 ✔ The design point: printTable was written ONCE and used with three completely different destinations. It never mentions files or strings — only std::ostream&. Adding a fourth destination (a network socket, a compressed stream, a syslog sink) requires NO change to printTable, only a new class deriving from ostream. That is the Open/Closed Principle from the software engineering paper, demonstrated in the standard library: open to extension, closed to modification. Note 91.0 printed as "91" — the default float formatting drops trailing zeros. Fixing that is the next topic.

The ostringstream case is worth dwelling on. It turns "produce output" into "produce a string", which means any function written against std::ostream& is automatically testable — no temporary files, no capturing stdout. If you take one design habit from this topic, make it "accept std::ostream&, not std::cout".

Worked example — stringstream as a converter

sstream_uses.cpp

#include <iostream>
#include <sstream>
#include <string>
#include <vector>

/* number -> string (the pre-C++11 to_string) */
template <typename T>
std::string toStr(const T &v) {
    std::ostringstream os; os << v; return os.str();
}

/* string -> number, with failure detection */
template <typename T>
bool fromStr(const std::string &s, T &out) {
    std::istringstream is(s);
    return (is >> out) && is.eof();   /* fully consumed? */
}

/* split a CSV line — getline with a custom delimiter */
std::vector<std::string> split(const std::string &line, char d) {
    std::vector<std::string> out;
    std::istringstream is(line);
    std::string field;
    while (std::getline(is, field, d)) out.push_back(field);
    return out;
}

int main() {
    std::cout << "  toStr(42)    = [" << toStr(42)    << "]\n";
    std::cout << "  toStr(3.14)  = [" << toStr(3.14)  << "]\n";
    std::cout << "  toStr(true)  = [" << toStr(true)  << "]\n";

    int n;
    std::cout << std::boolalpha;
    std::cout << "  \"123\"    -> " << fromStr("123", n)
              << " n=" << n << "\n";
    std::cout << "  \"12abc\"  -> " << fromStr("12abc", n)
              << "  (rejected: trailing junk)\n";
    std::cout << "  \"abc\"    -> " << fromStr("abc", n)
              << "  (rejected: not a number)\n";

    auto f = split("101,Ram Bahadur,87.5,Kathmandu", ',');
    std::cout << "  CSV -> " << f.size() << " fields:\n";
    for (size_t i = 0; i < f.size(); i++)
        std::cout << "    [" << i << "] " << f[i] << "\n";
    return 0;
}
Output:
  toStr(42)    = [42]
  toStr(3.14)  = [3.14]
  toStr(true)  = [1]
  "123"    -> true n=123
  "12abc"  -> false  (rejected: trailing junk)
  "abc"    -> false  (rejected: not a number)
  CSV -> 4 fields:
    [0] 101
    [1] Ram Bahadur
    [2] 87.5
    [3] Kathmandu

The `&& is.eof()` in fromStr is the important detail. Without it, "12abc" would return TRUE with out = 12 — the >> read 12 successfully and simply stopped at 'a'. Checking eof() confirms the ENTIRE string was consumed, so partial matches are rejected. That is exactly the difference between C's atoi (which silently returns 12 for "12abc") and a validating parse. atoi cannot report failure at all: atoi("abc") returns 0, indistinguishable from atoi("0"). Modern alternatives, in order of preference: std::stoi / std::stod throws on failure (C++11) std::from_chars no allocation, no locale, fastest (C++17) std::to_string number -> string (C++11) The stringstream technique above still matters because it works for ANY type with operator<< — including your own classes. And note split(): getline with a third argument uses ANY character as the delimiter, which makes CSV parsing three lines. The field "Ram Bahadur" kept its space, which >> would have broken in two.

🌍 Go further: iostreams are elegant but slow — the formatting machinery involves virtual calls, locales and dynamic allocation, which is why competitive programmers write ios::sync_with_stdio(false) to disconnect them from C's stdio and gain several-fold speedups. C++20 fixed this properly with std::format, which is type-safe like iostreams, fast like printf, and readable like Python's f-strings: std::format("{:.2f}", x). C++23 added std::print. Search "std::format vs iostream performance" — it is the future of C++ output and worth learning early.

💡 Exam angle: draw the hierarchy — ios_base → basic_ios → istream/ostream → iostream, with the file and string variants below. Name the four predefined streams and state that cerr is unbuffered while cout, cin and clog are buffered. Explain that cin is tied to cout, which is why prompts appear without endl. Be ready to show one function taking std::ostream& working with console, file and string destinations — that demonstrates the whole point of the hierarchy.

Syllabus points

istream, ostream hierarchy

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.