> 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-7.md).

# Lecture 7

### References Continued

```
int y = 10;
int &z = y;
```

**Things you cannot do without references**: ACRYNOM: UVPRA

* leave uninitialized X `int &x;`
  * Must be initialized to **lvalue** (left value)
    * values can occur on left side of assignment
* data with a permanent address (on stack or heap)
  * variables:
    * int \&x = y; (works)
    * int \&x = 3; (does not work)
      * 3 in itself does not have a memory address, when it is x=3 however, then x is stored in a place in memory and it has 3 in it
    * int \&x = y + z; (does not work)
* create pointer to a reference
  * int &\*x; (does not work)
* create a reference to a reference
  * eg. int &\&a=z; (does not work)
    * && means something else which you will see later
* create an array of references
  * eg. int \&r\[3]={y, y, y}; (does not work)

**What are references useful for?**

* Passing parameters to functions
  * in general, better to pass by reference
  * then, decide if const based on use of parameter

**Example:**

```
// Copy of value of parameter is used in f
int f(int x) {....}

struct Really Big {int arr[1000000];};

// Copies could be slow
int f(Really Big rb) {...}; 

// Making an alias (faster) - does not make a copy
// Passing by reference
// Can change rb
int g(ReallyBig &rb) {...}; 

// Making an alias (faster) - does not make a copy
// Cannot change rb
int h(const Really Big &rb) {...};
```

### Dynamic Memory Allocation

**Example in C:**

```
int *p = malloc(numberofElems*(sizeof(int)));
...
free(p);
```

**C++**:

* use new/delete -> type-aware, less error prone

**Example in C++:**

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

Node* np = new Node;
Node* np2 = new Node{5, nullptr};

// To deallocate:
delete np;
```

* New returns an address on the heap
  * initializes if we give it information

**Array Forms**

```
Node *myNodes = new Node[20];

delete [] myNodes;
```

### Returning by Value/Pointer/Reference

```
// copies Node that is here, copy it into stack that it is being returned to
Node getMeANode(){
  Node n;
  return n;
}
```

* copies node in function into the stack of the calling function
* could be expensuve due to making a copy

**Return by pointer/reference**

```
Node* getMeANode() {
  Node n;
  return &n;
}
```

* Not a good idea
* Return address in stack frame of the function
* var goes out of scope and is deallocated -> dangling pointer

```
Node* getMeANode() {
  Node* np = new Node;
  return np;
}
```

* np is in the stack of the function
  * np is pointing at heap data
* np goes out of scope but doesn't allocate the memory it is pointing at
* calling function needs to delete Node

### Operator Overloading

```
string s = "hello", t=" world";
string r = s+t;
int n = 7, m = 5;
int a = n + m;
string r = s + t;
calls string operator + (const string &s, const string &t);

int a = n + m;
calls int operator + (const int &x, const int &y)
```

```
struct Vec {
  int x,y;
};

Vec operator+(const Vec &v1, const+Vec&v2){
  Vec v {v1.x + v2.x, v1.y + v2.y}
  return v;
}
Vec x = z + y;

Vec operator *(const int k, const Vec &v){
  return {k*v.x, k*v.y}
}

// compiler initialized based on return type of function

Vec& operator += (Vec &v1, const Vec &v2){
  v1.x += v2.x;
  v1.y += v2.y;
  return v1;
}

Vec x = 2*v;

Vec operator = (const Vec &v, const int k){
  return k*v;
}

// calling the other operator* ensures the two are equivalent
```

### Overloading `<<` and `>>`

```
struct Grade {
  int theGrade;
};
ostream& operator <<(ostream& out, const Grade&g){
  out << g.theGrade << "%";
  return out;
}

Grade g {78};
cout << g << endl; // 78%

istream& operator >>(istream& in, Grade &g){
  in >> g.theGrade;
  if (g.theGrade < 0) g.theGrade = 0;
  if (g.theGrade > 100) g.theGrade = 100;
  return in;
}
```

### The Preprocessor

* Transforms program before compiler sees it
* preprocessor directive - #\_\_\_\_\_\_\_\_
  * eg. #include
  * eg. #define VAR VALUE