Home | Projects | Notes > C++ Programming > I/O & Streams

I/O & Streams

Overview

• Streams and I/O

• Stream manipulators

• Reading and writing to a text file

• Using string streams

Files, Streams and I/O

• C++ uses streams as an interface between the program, and input/output devices.

• Independent of the actual device

• Sequence of bytes

• Input stream provides data to the program

• Output stream receives data from the program

Common Header Files

Commonly Used Stream Classes

Global Stream Objects

• Global objects - Initialized before main executes

• Best practice is to use cerr for error messages and clog for log messages.

Stream Manipulators

• Streams have useful member functions to control formatting.

• Can be used on input and output streams

• The time of the effect on the stream varies

• Can be used as member functions or as a manipulator

  xxxxxxxxxx
  2
  1
  std::cout.width(10);        // Member function
  2
  std::cout << std::setw(10); // Manipulator
  

  Here, we'll focus on 'manipulator' usage.

• Common Stream Manipulators

  • Boolean

    • boolalpha, noboolalpha

  • Integer

    • dec, hex, oct, showbase, noshowbase, showpos, noshowpos, uppercase, nouppercase

  • Floating point

    • fixed, scientific, setprecision, showpoint, noshowpoint, showpos, noshowpos

  • Field width, justification and fill

    • setw, left, right, internal, setfill

  • Others

    • endl, flush, skipws, noskipws, ws

Boolean

• Used to format boolean types

• Default when displaying boolean values is 1 or 0

• Sometimes the string true or false are more appropriate

• Formatting boolean types

  xxxxxxxxxx
  2
  1
  std::cout << (10 == 10) << std::endl;       // 1
  2
  std::cout << (10 == 20) << std::endl;       // 0
  

  xxxxxxxxxx
  2
  1
  std::cout << std::noboolalpha;      // 1 or 0
  2
  std::cout << std::boolalpha;        // true or fase
  

  All further boolean output will be affected.

• Method version

  xxxxxxxxxx
  2
  1
  std::cout.setf(std::ios::boolalpha);
  2
  std::cout.setf(std::ios::noboolalpha);
  

• Reset to default

  xxxxxxxxxx
  1
  1
  std::cout << std::resetiosflags(std::ios::boolalpha);
  

Integer

• Default when displaying integer value is:

  • dec (base 10)

  • noshowbase - prefix used to show hexadecimal or octal

  • nouppercase - when displaying a prefix and hex values it will be lower case

  • noshowpos - no + is displayed for positive numbers

• These manipulators affect all further output to the stream.

• Setting base

  xxxxxxxxxx
  5
  1
  int num{255};
  2
  
  3
  std::cout << std::dec << num << std::endl;      // 255
  4
  std::cout << std::hex << num << std::endl;      // ff
  5
  std::cout << std::oct << num << std::endl;      // 377
  

• Showing the base

  xxxxxxxxxx
  6
  1
  int num{255};
  2
  
  3
  std::cout << std::showbase;                     // std::noshowbase
  4
  std::cout << std::dec << num << std::endl;      // 255
  5
  std::cout << std::hex << num << std::endl;      // 0xff ('0x' prefix for hexadecimal)
  6
  std::cout << std::oct << num << std::endl;      // 0377 ('0' prefix for octal)
  

  Displaying hex in uppercase

  xxxxxxxxxx
  4
  1
  int num{255};
  2
  
  3
  std::cout << std::showbase << std::uppercase;   // std::nouppercase
  4
  std::cout << std::hex << num << std::endl;      // 0XFF (note capitalized 'XFF')
  

• Displaying the positive sign

  xxxxxxxxxx
  10
  1
  int num1{255};
  2
  int num2{-255};
  3
  
  4
  std::cout << num1 << std::endl;     // 255
  5
  std::cout << num2 << std::endl;     // -255
  6
  
  7
  std::cout << std::showpos;          // std::noshowpos
  8
  
  9
  std::cout << num1 << std::endl;     // +255
  10
  std::cout << num2 << std::endl;     // -255
  

• Setting and resetting integer types

  Set using setf

  xxxxxxxxxx
  3
  1
  std::cout.setf(std::ios::showbase);
  2
  std::cout.setf(std::ios::uppercase);
  3
  std::cout.setf(std::ios::showpos);
  

  Reset to defaults

  xxxxxxxxxx
  4
  1
  std::cout << std::resetiosflags(std::ios::basefield);
  2
  std::cout << std::resetiosflags(std::ios::showbase);
  3
  std::cout << std::resetiosflags(std::ios::showpos);
  4
  std::cout << std::resetiosflags(std::ios::uppercase);
  

Floating Point

• Default when displaying floating point value is:

  • setprecision - number of digits displayed (6)

  • fixed - not fixed to a specific number of digits after the decimal point

  • noshowpoint - trailing zeros that are not displayed

  • nouppercase - when displaying in scientific notation

  • noshowpos - no + is displayed for positive numbers

• These manipulators affect all further output to the stream.

• Precision

  xxxxxxxxxx
  2
  1
  double num{1234.5678};
  2
  std::cout << num << std::endl;      // 1234.57  (Notice precision is 6 and rounding)
  

  xxxxxxxxxx
  2
  1
  double num{123456789.987654321};
  2
  std::cout << num << std::endl;      // 1.23457e+008 (Notice precision is 6)
  

  xxxxxxxxxx
  3
  1
  double num{123456789.987654321};
  2
  std::cout << std::setprecision(9);
  3
  std::cout << num << std::endl;      // 123456790 (Note that rounding occurs)
  

• Fixed

  xxxxxxxxxx
  3
  1
  double num{123456789.987654321};
  2
  std::cout << std::fixed;
  3
  std::cout << num << std::endl;      // 123456789.987654 (Precision 6 from the decimal)
  

  xxxxxxxxxx
  3
  1
  double num{123456789.987654321};
  2
  std::cout << std::setprecision(3) << std::fixed;
  3
  std::cout << num << std::endl;      // 123456789.988 (Precision 3 from the decimal)
  

  Note that rounding occurs.

• Scientific

  xxxxxxxxxx
  3
  1
  double num{123456789.987654321};
  2
  std::cout << std::setprecision(3) << std::scientific;
  3
  std::cout << num << std::endl;      // 1.23e+008 (Precision 3)
  

  Scientific uppercase

  xxxxxxxxxx
  3
  1
  double num{123456789.987654321};
  2
  std::cout << std::setprecision(3) << std::scientific << std::uppercase;
  3
  std::cout << num << std::endl;      // 1.23E+008 (Note the capital 'E')
  

• Displaying the positive sign

  xxxxxxxxxx
  3
  1
  double num{123456789.987654321};
  2
  std::cout << std::setprecision(3) << std::fixed << std::showpos;
  3
  std::cout << num << std::endl;      // +123456789.988 (Note the leading '+')
  

• Trailing zeros

  xxxxxxxxxx
  5
  1
  double num{12.34};
  2
  std::cout << num << std::endl;      // 12.34    (Note no trailing zeros - default)
  3
  std::cout << std::showpoint;
  4
  std::cout << std::endl;             // 12.3400 (Note trailing zeros up to precision)
  5
  
  

• Returning to general settings

  unsetf

  xxxxxxxxxx
  1
  1
  std::cout.unsetf(std::ios::scientific | std::ios::fixed);
  

  or

  xxxxxxxxxx
  1
  1
  std::cout << std::resetiosflags(std::ios::floatfield);
  

  Refer to the docs for other set/reset flags!

Field Width, Align and Fill

• Default when displaying floating point value is:

  • setw - not set by default

  • left - when no field width, right - when using field width

  • setfill - not set by default (blank space is used by default)

• Some of these manipulators affect only the next data element put on the stream.

• Defaults

  xxxxxxxxxx
  5
  1
  double num{1234.5678};
  2
  std::string hello{"Hello"};
  3
  std::cout << num << hello << std::endl; // 1234.57Hello
  4
  std::cout << num << std::endl;          // 1234.57
  5
  std::cout << hello << std::endl;        // Hello
  

• Field width (setw)

  xxxxxxxxxx
  5
  1
  double num{1234.5678};
  2
  std::string hello{"Hello"};
  3
  
  4
  std::cout << std::setw(10) << num << hello << std::endl;
  5
  // ---1234.57Hello ('-' represents space)
  

  xxxxxxxxxx
  7
  1
  double num{1234.5678};
  2
  std::string hello{"Hello"};
  3
  
  4
  std::cout << std::setw(10) << num 
  5
            << std::setw(10) << hello
  6
            << std::setw(10) << hello << std::endl;   
  7
  // ---1234.57-----Hello-----Hello ('-' represents space)
  

  xxxxxxxxxx
  8
  1
  double num{1234.5678};
  2
  std::string hello{"Hello"};
  3
  
  4
  std::cout << std::setw(10)
  5
            << std::left
  6
            << num            // Only affects num!
  7
            << hello << std::endl;    
  8
  // 1234.57---Hello ('-' represents space)
  

  xxxxxxxxxx
  8
  1
  double num{1234.5678};
  2
  std::string hello{"Hello"};
  3
  
  4
  std::cout << std::setw(10) << num 
  5
            << std::setw(10) << std::right << hello
  6
            << std::setw(15) << std::right << hello
  7
            << std::endl; 
  8
  // ---1234.57-----Hello----------Hello ('-' represents space)
  

• Filling fixed width (setfill)

  xxxxxxxxxx
  8
  1
  double num{1234.5678};
  2
  std::string hello{"Hello"};
  3
  
  4
  std::cout << std::setfill('*');
  5
  std::cout << std::setw(10)
  6
            << num
  7
            << hello << std::endl;    
  8
  // ***1234.57Hello
  

   

Reading from a Text File

Input Files (fstream and ifstream)

• fstream and ifstream are commonly used for input files

  1. #include <fstream>

  2. Declare an fstream or ifstream object

  3. Connect it to a file on your file system (opens it for reading)

  4. Read data from the file via the stream

  5. Close the stream

• Opening a file for reading with fstream

  xxxxxxxxxx
  1
  1
  std::fstream in_file{"../myfile.txt", std::ios::in};
  

  Opening for reading in binary mode

  xxxxxxxxxx
  1
  1
  std::fstream in_file{"../myfile.txt", std::ios::in | std::ios::binary};
  

• Opening a file for reading with ifstream

  xxxxxxxxxx
  2
  1
  std::ifstream in_file{"../myfile.txt", std::ios::in};
  2
  std::ifstream in_file{"../myfile.txt"};
  

  Open for reading in binary mode

  xxxxxxxxxx
  1
  1
  std::ifstream in_file{"../myfile.txt", std::ios::binary};
  

• Opening a file for reading with open()

  xxxxxxxxxx
  7
  1
  std::ifstream in_file;
  2
  std::string filename;
  3
  std::cin >> filename;   // Get the file name
  4
  
  5
  in_file.open(filename);
  6
  // Or
  7
  in_file.open(filename, std::ios::binary);
  

• Check if file opened successfully (is_open())

  xxxxxxxxxx
  10
  1
  if (in_file.is_open())  // Or simply 'if (in_file)' to test the stream object
  2
  {
  3
      // Read from it
  4
  }
  5
  else
  6
  {
  7
      // File could not be opened
  8
      // Does it exist?
  9
      // Should the program terminate?
  10
  }
  

• Closing a file

  Always close any open files to flush out any unwritten data!

  xxxxxxxxxx
  1
  1
  in_file.close();
  

• Reading from files using >>

  • We can use the extraction operator for formatted read the same way we used it with cin.

  xxxxxxxxxx
  6
  1
  int num{};
  2
  double total{};
  3
  std::string name{};
  4
  
  5
  in_file >> num;             // num <- 100
  6
  in_file >> total >> name;   // total <- 176.64, name <- "Jack"
  

  Where the contents of in_file is

  xxxxxxxxxx
  3
  1
  100
  2
  176.64
  3
  Jack
  

• Reading from files using getline()

  We can use getline() to read the file one line at a time.

  xxxxxxxxxx
  2
  1
  std::string line{};
  2
  std::getline(in_file, line);    // line <- "This is a line"
  

  Where the contents of in_file is

  xxxxxxxxxx
  1
  1
  This is a line
  

• Reading a text file one line at a time

  xxxxxxxxxx
  19
  1
  // Open file
  2
  std::ifstream in_file{"../myfile.txt"};
  3
  std::string line{};
  4
  
  5
  // Check if the file is open
  6
  if (!in_file)
  7
  {
  8
      std::cerr << "File open error" << std::endl;
  9
      return 1;   // Exit the program (main)
  10
  }
  11
  
  12
  while (!in_file.eof())  // While not at the end
  13
  {
  14
      std::getline(in_file, line);    // Read a line
  15
      std::cout << line << std::endl;     // Display the line
  16
  }
  17
  
  18
  // Close the file
  19
  in_file.close();
  

  The while loop in the example above can be re-written as

  xxxxxxxxxx
  2
  1
  while (std::getline(int_file, line))    // While not at the end read a line
  2
      std::cout << line << std::endl;
  

• Reading text file one character at a time (get())

  xxxxxxxxxx
  18
  1
  // Open file
  2
  std::ifstream in_file{"../myfile.txt"};
  3
  char c;
  4
  
  5
  // Check if the file is open
  6
  if (!in_file)
  7
  {
  8
      std::cerr << "File open error" << std::endl;
  9
      return 1;   // Exit the program (main)
  10
  }
  11
  
  12
  while (!in_file.get(c))     // While not at the end read a character
  13
  {
  14
      std::cout << c;         // Display the character
  15
  }
  16
  
  17
  // Close the file
  18
  in_file.close();
  

   

Writing to a Text File

Output Files (fstream and ofstream)

• fstream and ofstream are commonly used for output files

  1. #include <fstream>

  2. Declare an fstream or ofstream object

  3. Connect it to a file on your file system (opens it for writing)

  4. Write data to the file via the stream

  5. Close the stream

• Note

  • Output files will be created if they don't exist.

  • Output files will be overwritten (truncated) by default.

  • Can be opened so that new writes append.

  • Can be open in text or binary modes.

• Opening a file for writing with fstream

  xxxxxxxxxx
  1
  1
  std::fstream out_file{"../myfile.txt", std::ios::out};
  

  Opening for writing in binary mode

  xxxxxxxxxx
  1
  1
  std::fstream out_file{"../myfile.txt", std::ios::out | std::ios::binary};
  

• Opening a file for writing with ofstream

  xxxxxxxxxx
  2
  1
  std::ofstream out_file{"../myfile.txt", std::ios::out};
  2
  std::ofstream out_file{"../myfile.txt"};
  

  Open for writing in binary mode

  xxxxxxxxxx
  1
  1
  std::ofstream out_file{"../myfile.txt", std::ios::binary};
  

• Different actions upon opening a file for writing

  xxxxxxxxxx
  6
  1
  // Truncate (discard contents) when opening
  2
  std::ofstream out_file{"../myfile.txt", std::ios::trunc};
  3
  // Append on each write
  4
  std::ofstream out_file{"../myfile.txt", std::ios::app};
  5
  // Seek to end of stream when opening
  6
  std::ofstream out_file{"../myfile.txt", std::ios::ate};
  

• Opening a file for writing with open()

  xxxxxxxxxx
  7
  1
  std::ofstream out_file;
  2
  std::string filename;
  3
  std::cin >> filename;   // Get the file name
  4
  
  5
  out_file.open(filename);
  6
  // Or
  7
  out_file.open(filename, std::ios::binary);
  

• Check if file opened successfully (is_open())

  xxxxxxxxxx
  10
  1
  if (out_file.is_open()) // Or simply 'if (out_file)' to test the stream object
  2
  {
  3
      // Write to it
  4
  }
  5
  else
  6
  {
  7
      // File could not be opened or created
  8
      // Does it exist?
  9
      // Should the program terminate?
  10
  }
  

• Closing a file

  Always close any open files to flush out any unwritten data!

  xxxxxxxxxx
  1
  1
  out_file.close();
  

• Writing to files using <<

  • We can use the insertion operator for formatted write the same way we used it with cout.

  xxxxxxxxxx
  7
  1
  int num{100};
  2
  double total{176.64};
  3
  std::string name{"Jack"};
  4
  
  5
  out_file << num << "\n"
  6
           << total << "\n"
  7
           << name << std::endl;
  

  The contents of in_file will be

  xxxxxxxxxx
  3
  1
  100
  2
  176.64
  3
  Jack
  

• Copying a text file one line at a time

  xxxxxxxxxx
  26
  1
  // Open files
  2
  std::ifstream in_file{"../myfile.txt"};
  3
  std::ofstream out_file{"../copy.txt"};
  4
  
  5
  // Check if the input file is open
  6
  if (!in_file)
  7
  {
  8
      std::cerr << "File open error" << std::endl;
  9
      return 1;   // Exit the program (main)
  10
  }
  11
  
  12
  // Check if the output file is open
  13
  if (!out_file)
  14
  {
  15
      std::cerr << "File create error" << std::endl;
  16
      return 1;   // Exit the program (main)
  17
  }
  18
  
  19
  std::string line{};
  20
  
  21
  while (std::getline(int_file, line))    // While not at the end read a line
  22
      out_file << line << std::endl;      // Write a line to the output file
  23
  
  24
  // Close the files
  25
  in_file.close();
  26
  out_file.close();
  

• Copying a text file one character at a time (get()/put())

  xxxxxxxxxx
  28
  1
  // Open files
  2
  std::ifstream in_file{"../myfile.txt"};
  3
  std::ofstream out_file{"../copy.txt"};
  4
  
  5
  // Check if the input file is open
  6
  if (!in_file)
  7
  {
  8
      std::cerr << "File open error" << std::endl;
  9
      return 1;   // Exit the program (main)
  10
  }
  11
  
  12
  // Check if the output file is open
  13
  if (!out_file)
  14
  {
  15
      std::cerr << "File create error" << std::endl;
  16
      return 1;   // Exit the program (main)
  17
  }
  18
  
  19
  char c;
  20
  
  21
  while (!in_file.get(c))     // While not at the end read a character
  22
  {
  23
      out_file.put(c);        // Write the character to the file
  24
  }
  25
  
  26
  // Close the files
  27
  in_file.close();
  28
  out_file.close();
  

   

Using String Streams

• Allow us to read or write from strings in memory much as we would read/write to files

• Very powerful

• Very useful for data validation

• Using string streams

  1. #include <sstream>

  2. Declare an stringstream, istringstream, or ostringstream object

  3. Connect it to a std::string

  4. Read/write data from/to the string stream using formatted I/O

• Reading from a stringstream

  xxxxxxxxxx
  9
  1
  #include <sstream>
  2
  
  3
  int num{};
  4
  double total{};
  5
  std::string name{};
  6
  std::string info{"Moe 100 1234.5"};
  7
  
  8
  std::istringstream iss{info};
  9
  iss >> name >> num >> total;
  

• Writing to a stringstream

  xxxxxxxxxx
  9
  1
  #include <sstream>
  2
  
  3
  int num{100};
  4
  double total{1234.5};
  5
  std::string name{"Moe"};
  6
  
  7
  std::ostringstream oss{};
  8
  oss << name << " " << num << " " << total;
  9
  std::cout << oss.str() << std::endl;
  

• Validating input with stringstream

  xxxxxxxxxx
  11
  1
  int value{};
  2
  std::string input{};
  3
  
  4
  std::cout << "Enter an integer: ";
  5
  std::cin >> input;
  6
  
  7
  std::stringstream ss{input};
  8
  if (ss >> value)
  9
      std::cout << "An integer was entered";
  10
  else
  11
      std::cout << "An integer was NOT entered";