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:
One that copies from non-temp object (copy ctor) (lvalue reference)
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
Last updated
Was this helpful?