Lecture 10

Note: Careful with constructors that can take one param

struct Node {
  ...
  Node (int data):
    data{data}, next{nullptr};
}

• single-arg constructors create implicit conversions eg. Node n{4}

• but also Node n=4;

  • implicit concersion from int to Node

int f(Node n);
f(4); // works - 4 implicitly converted to Node

Node m{4}; // works fine
Node m = 4; // works - but 4 is not a node, it is an int 

DANGER:

• accidentally passing an int to a function expecting a Node

  • silent conversion

  • compiler does not signal an error

  • potential errors are not caught

How to fix

• Disable the implicit conversion - make constructor explicit

struct Node {
  ...
  explicit Node (int data): data{data}, next{nullptr} {}
}

Node n{4}; // OK!
Node n=4; // not allowed
f(4); // not allowed

f(Node {4}); // OK!

Destructors

When an object is destroyed:

• stack-allocatd: goes out of scope

• heap-allocated: is deleted

• A method called the desctructor is run

• Classes come with a destructor (just calls destructors for all fields that are objects)

What happens when an object is destroyed?

1. destructor body runs

2. fields' destructors are invoked in reverse declaration order (for fields that are objects)

3. space deallocated

When do we need to write a destructor?

Node *np=new Node {1, new Node {2, new Node {3, nullptr}}};

If np goes out of scope

• pointer np is reclaimed (stack-allocated)

• the list is leaked

If we say delete np;:

Write a destructor to ensure the whole list is freed:

struct Node {
  ...
  ~Node() {
    delete next;
  }
}

Now - delete np; frees the whole list

• invokes *next's destructors using recursion

• therefore, the whole list is deallocated

Copy Assignment Operator

Student billy {60,70,80};
Student jane=billy; // copy constructor

Student joey; // default constructor
joey = billy; // copy, but not a construction, it is the copy assignment operator -uses compiler-supplied default

• You may need to write your own copy assignment operator:

// WRONG AND DANGEROUS WAY:
struct Node {
  ...
  // so that cascading works (eg. a=b=c=d;)
  Node &operator = (const Node &other) {
    data = other.data;
    next=other.next?new Node{*other.next*}:nullptr;
    return *this;
  }
}

Why is this way dangerous?

Node n {1, new Node {2, new Node {3, nullptr}}};

// deletes n and then tries to copy n to n
// undefined behaviour
n=n; 

When writing operator=, always watch out for self-assignment:

struct Node {
  ...
  Node &operator=(const Node &other) {
    if (this == &other) return *this;
    data = other.data;
    delete next;
    
    // if "new" fails, this method will abort
    // next has been deleted, but not reassigned, therefore we have pointers at dead memory which means we have a corrupted list
    next = other.next? new Node {*other, next}: nullptr;
    return *this;
  }
}

Better Way:

Node &Node::operator=(const Node &other) {
  if (this == &other) return *this;
  Node *tmp = next;
  next = other.next? new Node {*other.next}:nullptr;
  data = other.data
  delete tmp;
  return *this; // if new fails, node will still be in its original state (not corrupted)
}

Note:

*other.next // equivalent to *(other.next)
other->next // equivalent to (*other).next

Alternative: copy-and-swap idiom

#include <utility>

struct Node {
  ...
  void swap (Node &other) {
    using std::swap;
    swap(data, other.data);
    swap(next, other.next);
  }

  Node &operator = (const Node &other) {
    Node tmp = other;
    swap(tmp);
    return *this;
  }
};

Rvalues and Rvalue references

Recall:

• an lvalue is anything with an address

• an lvalue ref (&) is like a const pointer with auto-deret

  • always initialized to an lvalue

Now consider:

Node plusOne (Node n) {
  for (Node *p=&n; p; p=p->next) {
    ++p->data;
  }
  return n;
}

Node n {1, new Node {2, nullptr}};
Node n2 = plusOne(n); //copy construction

• compiler creates a temporary object to hold the result of plusOne

• other is a reference to this temporary

  • copy constructor deep-copies from this tmeporary

But