In [1]:

#include <iostream>
#include <iomanip>   // for setw and setfill stream manipulators
#include <sstream>   // for ostringstream class
#include <string>
using namespace std;

Stream I/O¶

Streams¶

C++ I/O occurs in streams, which are sequences of bytes
- In input operations, the bytes flow from a device to main memory
- In output operations, bytes flow from main memory to a device
A stream is an abstraction for input/output. You can think of it as a source (input) or destination (output) of characters of indefinite length.

`iostream`¶

The iostream library provides many class templates for performing common I/O operations
- basic_istream for stream input operations
  - istream is a basic_istream<char> that enables char input, i.e. cin's type
- basic_ostream for stream output operations
  - ostream is a basic_ostream<char> that enables char output, i.e. the type of cout, cerr and clog

iostreams

Character Output¶

The basic_ostream member function put outputs one character at a time.
- The put function also may be called with a numeric expression that represents an ASCII value

In [2]:

std::cout.put('A');

In [3]:

std::cout.put(65);

`getline`¶

Standard Library global function getline reads a line of text.
- When you press Enter key after typing data, the system inserts a newline in the input stream
- Function getline reads from the standard input stream object cin the characters the user enters, up to, but not including, the newline, which is discarded
- Input can contain multiple words separated by a space
- getline places the characters in its second argument

In [8]:

{
    std::string s;
    std::cin >> s;
    std::cout << "String 's' is \"" << s << "\"" << std::endl;
}

jkljfd fsdkjf dkdlkfldkf
String 's' is "jkljfd"

In [10]:

{
    std::string s;
    std::getline(std::cin, s);
    std::cout << "String 's' is \"" << s << "\"" << std::endl;
}

 lfg jgkfg kfjgkfjgfk kfjgkfjg  
String 's' is " lfg jgkfg kfjgkfjgfk kfjgkfjg  "

Stream Manipulators¶

The stream manipulators provide capabilities such as
- setting field widths
- setting precision
- setting and unsetting format state
- setting the fill character in fields
- flushing streams
- inserting a newline into the output stream (and flushing the stream)
- inserting a null character into the output stream
- skipping white space in the input stream

setw(n) sets the minimum width of the input for the next stream operation. If the data doesn't meet the minimum field requirement, it is padded with the default fill character until it is proper size.

In [12]:

std::cout << "Output:" << 10 << std::endl;

Output:10

In [13]:

#include <iostream> // for setw()

std::cout << "Output: " << std::setw(5) << 10 << std::endl;

Output:    10

setprecision(n) sets the precision of the stream out or in to exactly n.

In [19]:

#include <iostream>
#include <cmath> // for pow() 
#include <iomanip> // for setprecision()

std::cout << "1 petabyte is 2^50 bytes = "
          << std::setprecision(20) 
          << pow(2., 50) << " bytes" 
          << std::endl;

1 petabyte is 2^50 bytes = 1125899906842624 bytes

boolalpha determines whether or not the stream should output boolean values as 1 and 0 or as true and false. The opposite manipulator is noboolalpha, which reverses this behavior.

In [31]:

std::cout << true << std::endl;

In [32]:

std::cout << std::boolalpha<< true << std::endl;

true

oct, dec, hex set the radix on the stream to either octal (base 8), decimal (base 10), or hexadecimal (base 16). This can be used either to format output or change the base for input.
More example of stream library use in here: https://blog.andersonbanihirwe.dev/2018/01/20/play-interactively-with-cpp-streams.html

In [39]:

std::cout << 1000 << std::endl;

In [36]:

std::cout << std::oct << 1000 << std::endl;

In [37]:

std::cout << std::hex << 1000 << std::endl;

3e8

In [38]:

std::cout << std::dec << 1000 << std::endl;

Once the fill character is specified with setfill, it applies for all subsequent values that are displayed in fields wider than the value being displayed
setfill is a sticky setting
This is in contrast to setw, which applies only to the next value displayed
setw is a nonsticky setting

In [40]:

std::cout << std::setfill('0')  << std::setw(4) << 10 << std::endl;

In [41]:

std::cout << 10 << std::endl;

In [42]:

std::cout << std::setw(8) << 10 << std::endl;

00000010

Stream Sticky Setting¶

Parameterized stream manipulator setfill specifies the fill character that's displayed when an integer is output in a field wider than the number of digits in the value.
Once the fill character is specified with setfill, it applies for all subsequent values that are displayed in fields wider than the value being displayed:
- setfill is a sticky setting
Each sticky setting should be restored to its previous setting when it’s no longer needed.
- in contrast to setw, which applies only to the next value displayed setw is a nonsticky setting

Type-Safe I/O¶

C++ offers type-safe I/O.
The << and >> operators are overloaded to accept data items of specific types.
If unexpected data is processed, various error bits are set, which the user may query to determine whether an I/O operation succeeded or failed.
If operators << and >> have not been overloaded for a user-defined type and you attempt to use those operators to input into or output the contents of an object of that user-defined type, the compiler reports an

error.

Unformatted I/O¶

Unformatted input/output is performed using istreams read and ostreams write member functions, respectively.
- read inputs bytes to a built-in array of chars in memory
- write outputs bytes from a built-in array of chars.

In [43]:

{
    char buffer[]{"HAPPY BIRTHDAY"};
    std::cout.write(buffer, 10);
}

HAPPY BIRT

In [44]:

{
    char buffer[]{"HAPPY BIRTHDAY"};
    std::cout << "Enter a sentence:\n";
    std::cin.read(buffer, 6);
    std::cout << "\nThe sentence entered was:\n";
    std::cout << buffer << std::endl;
}

Enter a sentence:
hello-hello

The sentence entered was:
hello-BIRTHDAY

String Stream Processing¶

ostringstream objects provide the same functionality as cout, but write their output to string
- ostringstream's str member function gets the formatted string
- It's defined in the header <sstream>

In [4]:

{
    int hour{10}, minute{3}, second{44};
    std::ostringstream output;
    output << std::setfill('0') << std::setw(2) << hour << ":"
        << std::setw(2) << minute << ":" << std::setw(2) << second;
    std::cout << output.str() << std::endl; // returns the formatted string
    std::stringstream input{"10 d"};
    char c;
    int n;
    input >> n >> c;
    std::cout << "n: " << n << ", c: " << c << std::endl;
}

10:03:44
n: 10, c: d

We can pass an integer to the C++ Standard Library function to_string (from header <string> ), which converts a numeric value to a string object.

C++ Strings¶

C++ offers two types of strings
- string class objects, and
- C-style, pointer-based strings (C strings).
C++ string class is preferred it eliminates many of the security problems that can be caused by manipulating C strings.
- Also, if you work with legacy C and C++ programs, you're likely to encounter pointer-based strings.

Characters¶

Characters are the fundamental building blocks of C++ source programs.
Character constant
- An integer value represented as a character in single quotes.
- The value of a character constant is the integer value of the character in the machine’s character set.

In [5]:

{
    char c = 'A';
    int i{c};
    std::cout << "Char: '" << c << "' is an integer: "<< i << std::endl;
}

Char: 'A' is an integer: 65

Strings¶

A string is a series of characters treated as a single unit.
- May include letters, digits and various special characters such as +, −, *, /and $.
String literals, or string constants, in C++ are written in double quotation marks

In [7]:

{
    std::string s{"abcd3340+-\\$"};
    std::cout << "Some string: \"" << s << "\"" << std::endl;
}

Some string: "abcd3340+-\$"

Pointer-Based Strings¶

A pointer-based string is a built-in array of characters ending with a null character '\0'.
A string is accessed via a pointer to its first character.
The sizeof a string literal is the length of the string including the terminating null character.
A string literal may be used as an initializer in the declaration of either a built-in array of chars or a variable of type const char*.
The characters are output until a terminating null character is encountered;
- the null character is not displayed.

In [8]:

{
    char color[]{"blue"};
    const char* colorPtr{"green"};    
    std::cout << "Some string: \"" << color << "\"" << std::endl;
    std::cout << "Another string: \"" << colorPtr << "\"" << std::endl;    
}

Some string: "blue"
Another string: "green"

Accessing Characters¶

Because a C string is a built-in array of characters, we can access individual characters in a string directly with array subscript notation.

In [9]:

{
    char color[]{"blue"};    
    std::cout << "Some string: \"" << color << "\"" << std::endl;
    std::cout << "A third character in the string is '" << color[2] << "'" << std::endl;
    color[0] = 'g';
    std::cout << "Same string: \"" << color << "\"" << std::endl;
}

Some string: "blue"
A third character in the string is 'u'
Same string: "glue"

String Class¶

String variables can hold character string values such as "Jane Green".
A string is actually an object of the C++ Standard Library class string
- It's defined in the header <string>.
- The class name string, belongs to namespace std.

String Class Operators¶

Class string has overloaded operators and several other useful member functions, including empty, substr and at
Class string has overloaded equality and relational operators perform lexicographical comparisons

In [10]:

std::string s1{"happy"};
std::string s2{" birthday"};
std::string s3; // creates an empty string
// test overloaded equality and relational operators
std::cout << boolalpha
    << "s1 is \"" << s1 << "\"; s2 is \"" << s2
    << "\"; s3 is \"" << s3 << '\"' << " and is empty: " << s3.empty()
    << "\n\nThe results of comparing s2 and s1:"
    << "\ns2 == s1 yields " << ( s2 == s1 )
    << "\ns2 != s1 yields " << ( s2 != s1 )
    << "\ns2 > s1 yields " << ( s2 > s1 )
    << "\ns2 < s1 yields " << ( s2 < s1 )
    << "\ns2 >= s1 yields " << ( s2 >= s1 )
    << "\ns2 <= s1 yields " << ( s2 <= s1 );

s1 is "happy"; s2 is " birthday"; s3 is "" and is empty: true

The results of comparing s2 and s1:
s2 == s1 yields false
s2 != s1 yields true
s2 > s1 yields false
s2 < s1 yields true
s2 >= s1 yields false
s2 <= s1 yields true

Class string provides member function empty to determine whether a string is empty
- Returns true if the string is empty; otherwise, it returns false.
Class string has overloaded += operator performs string concatenation.
- A string literal can be appended to a string object by using operator +=

In [11]:

// test overloaded string concatenation assignment operator
std::cout << "s1 += s2 yields s1 = ";
s1 += s2; // test overloaded concatenation
std::cout << s1;

// test string concatenation with a C string
std::cout << "\n\ns1 += \" to you\" yields\n";
s1 += " to you";
std::cout << "s1 = " << s1;

s1 += s2 yields s1 = happy birthday

s1 += " to you" yields
s1 = happy birthday to you

Class string does provide bounds checking in its member function at, which throws an exception if its argument is an invalid subscript.
- If the subscript is valid, function at returns the character at the specified location as a modifiable lvalue or a nonmodifiable lvalue (e.g., a const reference), depending on the context in which the call appears.

In [12]:

// test copy constructor
std::string s4{s1};
std::cout << "s4 = " << s4 << "\n\n";

// test overloaded copy assignment (=) operator with self-assignment
std::cout << "assigning s4 to s4\n";
s4 = s4;
std::cout << "s4 = " << s4;

// test using overloaded subscript operator to create lvalue
s1[0] = 'H';
s1[6] = 'B';
std::cout << "\n\ns1 after s1[0] = 'H' and s1[6] = 'B' is:\n" << s1 << "\n\n";

s4 = happy birthday to you

assigning s4 to s4
s4 = happy birthday to you

s1 after s1[0] = 'H' and s1[6] = 'B' is:
Happy Birthday to you

Stream I/O¶

Streams¶

iostream¶

Character Output¶

getline¶

Stream Manipulators¶

Stream Sticky Setting¶

Type-Safe I/O¶

Unformatted I/O¶

String Stream Processing¶

C++ Strings¶

Characters¶

Strings¶

Pointer-Based Strings¶

Accessing Characters¶

String Class¶

String Class Operators¶

`iostream`¶

`getline`¶