> For the complete documentation index, see [llms.txt](https://lauradang.gitbook.io/notes/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://lauradang.gitbook.io/notes/c++/cs_246/lecture-5.md).

# 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)
}
```