# Lecture 5

### Function from last lecture

```
# include <iostream>
using namespace std; 

int main() { 
  int x,y; cin >> x >> y; // read two integers from cin, skipping whitespace 
  cout << x+y << endl; // reads whitespace delimited input 
} 
```

* Input fed into this function might not be an int
  * could be a number that doesn't fit in an int

### Failure to Read Int

* 0 is stored into int
* cin is set to know we failed to read from it
* If read fails, `cin.fail()` will be true
* If `EOF`, then `cin.eof()`, and `cin.fail()` are both true
* If `cin` takes something that is bigger than an int, long, etc. It will fail, otherwise, will do implicit conversion

### Example 1:

**Read all ints from cin, and echo them one per line to stdout. Stop if EOF or a non-int is entered.**

```
# include <iostream>
using namespace std; 

int main(){
  int i;
  while (true) {
    cin >> i;
    if (cin.fail()) break;
    cout << i << endl;
  }
}
```

#### There is an implicit conversion from cin to bool:

```
// if cin hasn't failed or reached EOF then it is true
if (cin) { 
  ...
}
```

### `>>`

* C's right bit shift operator

```
// shifts a's bits to the right by b bits
a >> b  
```

* The operator `>>` with `cin` as the first operand, C++ will call the "get from" version of operator `>>`.

```
cin >> x >> y >> x; // cascading
// runs cin >> x first, then cin >> y, then cin >> z
// always returns cin
// if one cin step fails, it will return cin with cin.fail() set to true (does not read anymore, just quits)
```

### Rewrite Example 1:

```
# include <iostream>
using namespace std; 

int main() {
  int i;
// attempts to read i and returns cin which is implicitly converted to a bool
// if read succeeds, while loop runs
  while (cin >> i) { 
    cout << i << endl;
  }
}
```

### Example:

**Read ints from input until we reach EOF. Ignore any non-integers.**

```
# include <iostream>
using namespace std; 

int main() {
  int i;
  while (true) {
    if (!(cin >> i)) {
      cout << i << endl;
      if (cin.eof()) break;
      else {
        cin.clear(); // clears cin's fail bit
        cin.ignore(); // removes the char from stream
      }
    } 
  }
  
  int j;
  cin.clear();
  cin >> j;
  cout << "This is the last int: " << j << endl;
}

// run file in terminal
$ g++ -std=c++14 readInts5.cc -o readInts
$ ./readInts
```

### Example

**Print hexadecimal representation of 95.**

```
cout << hex << 95 << endl;
std::hex // an IO manipulator
// All subsequent ints printed in hexadecimal
cout << dec;
cout << bin; // binary, stored in <iomanip>
```

## Strings

In C: an array of chars `char* or char[]`

* Terminated with '\0'
* Explicit memory management
* bad if null terminator was forgotten

In C++: `#include <string> type std::string`

* manage their own memory
* string takes care of termination
  * easier to manipulate

### Initialization

```
string s = "hello";
```

* "hello" is still a string literal
  * still a C-style string
* s is initialized from the literal string and maintains its characters

### String Operations

```
s1 == s2;
s1 != s2;
s1 <= s2; // lexicographical
s1.length(); // length in constant time
s[0]; // fetch chars
s3 = s1 + s2; // concatenation
s3 += s4; // short form concatenation
s.substr(n,m) // n = first char to grab, m = # of char to grab, returns C++ style string
```

### Example

```
int main() {
  string s;
  // Reads string -> whitespace delimited (skips leading whitespaces)
  // Stop reading at next whitespace char
  cin >> s; 
  cout << s << endl;
}
```

#### Reading with whitespace: `getline(cin, s)`

* Reads entire line until a newline character
* Other delimiters possible

### File Access

```
# include <iostream>
# include <fstream> // file streams
using namespace std;

int main() {
  ifstream file { "name.txt" };
  // Declaring and initializing on ifstream. Opens file
  int x;
  file >> x; // file instead of cin (works the same way)
}
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://lauradang.gitbook.io/notes/c++/cs_246/lecture-5.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.