C++ Streams: Sources and Destinations of Data

std::ios_base Member Functions for Formatting

flags()

Get/set format flags (public member function). Prototypes: fmtflags flags() const; and fmtflags flags (fmtflags fmtfl);, where ios_base::fmtflags is a bitmask type.

setf()

Set specific format flags (public member function)

unsetf()

Clear specific format flags (public member function)

precision()

Get/Set floating-point decimal precision (public member function)

width()

Get/set field width (public member function)

streamsize width() const;
streamsize width (streamsize wide);

// field width
#include <iostream>     // std::cout, std::left

int main () {
  std::cout << 100 << '\n';
  std::cout.width(10);
  std::cout << 100 << '\n';
  std::cout.fill('x');
  std::cout.width(15);
  std::cout << std::left << 100 << '\n';
  return 0;
}

std::ios_base::fmtflags

(From https://cplusplus.com/ios_base::fmtflags)

std::ios_base::fmtflags is a type for stream format flags. It is used as a parameter and/or return value by the member functions flags(), setf() and unsetf().

The values passed and retrieved by these functions can be any valid combination of the following member constants:

Three additional bitmask constants made of the combination of the values of each of the three groups of selective flags can also be used:

The values of these constants can be combined into a single fmtflags value using the OR bitwise operator (|).

These constants are defined as public members in the ios_base class. Therefore, they can be refered to either directly by their name as ios_base members (like ios_base::hex) or by using any of their inherited classes or instantiated objects, like for example ios::left or cout.oct.

These values of type ios_base::fmtflags should not be confused with the manipulators that have the same name but in the global scope, because they are used in different circumstances. The manipulators cannot be used as values for ios_base::fmtflags, as well as these constants shouldn't be used instead of the manipulators. Notice the difference:

ios_base::skipws     // constant value of type ios_base::fmtflags
skipws               // manipulator (global function) 

Notice that several manipulators have the same name as these member constants (but as global functions instead) - see manipulators. The behavior of these manipulators generally corresponds to the same as setting or unsetting them with ios_base::setf or ios_base::unsetf, but they should not be confused! Manipulators are global functions and these constants are member constants. For example, showbase is a manipulator, while ios_base::showbase is a constant value that can be used as parameter with ios_base::setf.

Example:

// using ios_base::fmtflags
#include <iostream>     // std::cout, std::ios_base, std::ios,
                        // std::hex, std::showbase
int main () {

  // using fmtflags as class member constants:
  std::cout.setf (std::ios_base::hex , std::ios_base::basefield);
  std::cout.setf (std::ios_base::showbase);
  std::cout << 100 << '\n';

  // using fmtflags as inherited class member constants:
  std::cout.setf (std::ios::hex , std::ios::basefield);
  std::cout.setf (std::ios::showbase);
  std::cout << 100 << '\n';

  // using fmtflags as object member constants:
  std::cout.setf (std::cout.hex , std::cout.basefield);
  std::cout.setf (std::cout.showbase);
  std::cout << 100 << '\n';

  // using fmtflags as a type:
  std::ios_base::fmtflags ff;
  ff = std::cout.flags();
  ff &= ~std::cout.basefield;   // unset basefield bits
  ff |= std::cout.hex;          // set hex
  ff |= std::cout.showbase;     // set showbase
  std::cout.flags(ff);
  std::cout << 100 << '\n';

  // not using fmtflags, but using manipulators:
  std::cout << std::hex << std::showbase << 100 << '\n';

  return 0;
}

The code shows some different ways of printing the same result, using both the fmtflags member constants and their homonymous manipulators.

Template Parameters

charT

Character type

Shall be a non-array POD type

Aliased as member type basic_ios::char_type

traits

Character traits class that defines essential properties of the characters used by stream objects (see char_traits)

traits::char_type shall be the same as charT

Aliased as member type basic_ios::traits_type

Flags/Members

char_type fill() const;
char_type fill (char_type fillch);

// using the fill character
#include <iostream>     // std::cout

int main () {
  char prev;

  std::cout.width (10);
  std::cout << 40 << '\n';

  prev = std::cout.fill ('x');
  std::cout.width (10);
  std::cout << 40 << '\n';

  std::cout.fill(prev);

  return 0;
}

std::istream_iterator*

Istream iterators are input iterators that read successive elements from an input stream (such as cin). They are constructed from a std::basic_istream object, to which they become associated, so that whenever operator++ is used on the iterator, it extracts an element from the stream (using operator>>).

This kind of iterator has a special state as an end-of-stream iterator, which is acquired if an input operations fails (as returned by bool std::basic_ios::fail() const after an operation with the associated stream), and is also the resulting value of a default-constructed object.

Syntax:

template <
  class T,
  class charT=char,
  class traits=char_traits<charT>,
  class Distance = ptrdiff_t>
class istream_iterator;

where T is the type of elements extracted from the stream.

Its member functions are:

An example:

// istream_iterator example
#include <iostream>     // std::cin, std::cout
#include <iterator>     // std::istream_iterator

int main () {
  double value1, value2;
  std::cout << "Please, insert two values: ";

  std::istream_iterator<double> eos;              // end-of-stream iterator
  std::istream_iterator<double> iit (std::cin);   // stdin iterator

  if (iit!=eos) value1=*iit;

  ++iit;
  if (iit!=eos) value2=*iit;

  std::cout << value1 << "*" << value2 << "=" << (value1*value2) << '\n';

  return 0;
}

std::ostream_iterator

Ostream iterators are output iterators that write sequentially to an output stream (such as cout). They are constructed from a basic_ostream object, to which they become associated, so that whenever an assignment operator (=) is used on the ostream_iterator (dereferenced or not) it inserts a new element into the stream.

Optionally, a delimiter can be specified on construction. This delimiter is written to the stream after each element is inserted.

Syntax:

template <class T, class charT=char, class traits=char_traits<charT> >
class ostream_iterator;

where T is the type of elements inserted into the stream.

Its member functions are:

An example:

// ostream_iterator example
#include <iostream>     // std::cout
#include <iterator>     // std::ostream_iterator
#include <vector>       // std::vector
#include <algorithm>    // std::copy

int main () {
  std::vector<int> myvector;
  for (int i=1; i<10; ++i) myvector.push_back(i*10);

  std::ostream_iterator<int> out_it (std::cout,", ");
  std::copy ( myvector.begin(), myvector.end(), out_it );
  return 0;
}

Output:

10, 20, 30, 40, 50, 60, 70, 80, 90,