# Lecture 6

### Example

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

int main() {
  ifstream file {"suite.txt"}; // opens file during initialization
  string s;
  while (file >> s) {
  cout << s << endl;
  }
} // file is closed when ifstream goes out of scope
```

### `cin -> ifstream` input file stream

### `cout -> ofstream` output file stream

```
ofstream file{"name"}
```

**Note:** Anywhere cin/cout is usable, an ifstream/ofstream is usable.

### String Streams

An interface to interact with a string like it's a stream. **Library**: `include <sstream>` **Example:** Convert int into a string

```
#include <sstream>

string intToString(int n) {
  ostringstream oss;
  oss << n; // cout << n;
  return oss.str();
}
```

**Example:** Convert a string into a number

```
int n;
while(true) {
  cout << "Enter a number" << endl;
  string s;
  cin >> s; // cin won't fail unless it is EOF
  istringstream iss{s}; // initialization iss w contents of s
  if (iss >> n) break;
  cout << "I said, ";
}
```

**Example:** print ints to cout, ignore non-ints

```
int main() {
  string s;
  while (cin >> s) {
    istringstream iss{s};
    int n;
    if (iss >> n) cout << n << endl;
  }
}
```

Why don't we need to clear and ignore iss?

* Each iteration initializes its own istring stream.

What will the input "h3110" print?

```
// Old version:
>> 3
>> 0

// This version:
 cin >> s // reads "h3110"
 >> 
// prints nothing
```

**Declare string and not initializing**

```
string s; // s is an empty string, not null
```

### Default function parameters

**Example:**

```
void printSuiteFile(string name="suite.txt") {
  ifstream file {name};
  string s;
  while (file >> s) cout << s << endl;
}
// can call function without calling parameter
printSuiteFile(); // name is default parameter -> "suite.txt"

// can also call function with parameter other than default
printSuiteFile("suite2.txt") // Could also be std::string
```

**Example:** Optional Parameters must be on the right (if it starts on the left, program will not compile) eg. `(int x=5,int y) # will not compile`

```
// Can do:
void foo (int x, string s, int z)

// Cannot do:
void foo (int x, string s="hello", int z)

// Can do:
void foo (int x=4, string s="hello", int z=5)
```

### Overloading

Giving multiple functions to one function name in C++, but in C, you must only have unique function names **Example in C:**

```
int negInt(int n) { 
  return -n;
}

bool negBool(bool b) {
  return !b;
}
```

**Example in C++:**

```
int neg(int n) {
  return -n;
}

bool neg(bool b) {
  return !b;
}
```

**What is a valid overload?**

* Compiler looks at the number and types of parameters.
* Based on **params**, decides the function to call (this decision is made at compile time)
* Overloads must differ in **number** or **types** of args.
* C++ does not overload on **return type**.
  * i.e. if two functions have the same name and params, but different return types
  * This is not valid because C++ only checks params
* Must be no valid way to call function with same params including default params
  * does not compile if you call function without specifying default param, if it is specified, it will compile

### Structures

**Example:**

```
struct Node {
  int n;
  Node *next; // in C++, "struct Node*" is not needed, only need Node*"
}; // semicolon needed
```

**This does not work:**

```
struct Node {
  int n;
  Node next;
}
```

Why not?

* size of struct must be known when it is defined
* struct is a recursive class, there is no pointer present - - when pointer is present, computer knows the size of the pointer, so it adds the size of a pointer and an int to get the size

### Constants

```
const int maxGrade = 100; // consts must be initialized
```

Try to declare as many things const as possible

```
Node n1 {5, nullptr}; // synxtax for null pointers in C++, don't use null or 0
```

```
const Node n2=n1; // immutable copy of n1 (cannot alter n2)
// Even if you alter n1, it will not alter n2 because it's its own copy
```

### Parameter Passing

**Pass-by-value**: A copy of argument is used in the function

```
void inc(int n) {
  ++n;
  ...
};

int main() {
  int x=7;
  inc(x);
  cout << x << endl;
  // pass by value not reference
}

// prints 7 when called
>> 7
```

```
void inc(int *n) {
  ++ *n;
  ...
}

int main() {
  int n=7;
  inc(&n); // address of n
  cout << n << endl;
};

// prints 8 when called
>> 8
```

**Why does `cin >> x` alter x? Why not `cin >> &x`?**

* C++ has another pointer-like type called **References**

### References

References are like const pointers with automatic dereferencing.

**Example:**

```
int y = 10;
int &z = y; // z is "pointing" to y
z = 12; // NOT *z = 12
cout << y << endl; // prints 12
```

In all cases, z behaves exactly like y. z is an alias to y -> it's another name for y

```
void inc(int &n) {
  ++n;
}

int x=3;
inc(x);
cout << x << endl; // prints 4
```

This is an l value reference:

```
int &x; 
```

* l value: left value
* must be initialized to something that can be on the left of an assigment
