# Lecture 11

### Copy Assignment Operator

**EXAMPLE**:

```
Student billy {...};
Student bobby {billy}; /// copy ctor
Student jane;
jane = billy; // copy assignment
jane.operator = (billy);

n1=n2; // n1.operator=(n2);
n1=n2=n3; // n2.operator = (n3);
```

**EXAMPLE**:

```
Node & Node::operator=(const Node &other) {
  if (this==&other) return *this; // self assignment check
  data = other.data;
  
  delete next; // since we are updating on existing obj
  
  next = other.next? new Node {*other.next}=nullptr;
  return *this;
}
```

* If new fails, stop executing
  * next is a "dangling pointer"

**New assignment operator:**

```
Node &Node::operator=(const Node &other) {
  if (this==&other) return *this;
  Node *temp=next;
  next = other.next? new Node {*other.next}=nullptr;
  data = other.data;
  delete temp;
  return *this;
}
// Switch of order; keeping temp in class
// Assign new, then delete
```

### Copy and Swap Idiom

```
struct Node {
  void swap(Node &);
  Node &operator = (const Node &);
};

#include <utility>
  void Node::swap(Node &other) {
  swap(data, other.data);
  swap(next, other.next);
}

Node &Node: operator=(const Node &other) {
  Node temp{other};
  this->swap(temp); // automatically deleted after shifting out of scope
  return *this;
} // requires correct dtor
```

**EXAMPLE**: Classes/vvalue/node.cc

```
// 2 copy constructors for 2 nodes
Node plusOne (Node n) {
  return n;
}

// 2 calls to constructor
Node n {1, new Node {2, nullptr}};
Node n1 {plusOne(n)}; 
```

**Note**: we would like 2 kinds of constructors:

1. One that copies from non-temp object (copy ctor) (lvalue reference)
2. One that steals from a temp obj are r-values (rvalue reference)

**Rvalue Reference**: Reference to a temporary Node <- Node Node & <- lvalue Node && <- rvalue reference

### Move Constructor

```
Node::Node(Node &other):
  data {other.data},
  next {other.next} {
    other.next = nullptr;
  }
  
n1 = plusOne(n); //temp rvalue
n1 = n2; //lvalue
```

### Move Assignment Operator

```
Node &Node::operator=(Node &&other) {
  swap(other);
  return *this;
}
// Copy/move elision
```


---

# 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-11.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.