Week 05 / 14 Object-Oriented Programming

Lab 5 - Copy semantics and the Rule of Three

We copy an object that owns heap memory, watch the compiler-generated copy share that memory, and then write the destructor, copy constructor and operator= that make copies independent.

Plan (90 min)

Starting program

This class owns two heap blocks: the name and the grades. It has a destructor, but no copy constructor and no operator=. Read it, then run it.

#include <iostream>
#include <cstring>
using namespace std;

class Student {
    char* name;
    int* grades;
    int noGrades;
public:
    Student(const char* n, const int* g, int count) {
        name = new char[strlen(n) + 1];
        strcpy(name, n);
        noGrades = count;
        grades = new int[noGrades];
        for (int i = 0; i < noGrades; i++) grades[i] = g[i];
    }
    ~Student() {
        cout << "~Student frees name at " << (void*)name << endl;
        delete[] name;
        delete[] grades;
    }
    void setGrade(int i, int value) { grades[i] = value; }
    void print() const {
        cout << name << ":";
        for (int i = 0; i < noGrades; i++) cout << " " << grades[i];
        cout << "   name at " << (void*)name << ", grades at " << grades << endl;
    }
};

int main() {
    int g[] = {8, 9, 7};
    Student s1("Ana", g, 3);
    Student s2 = s1;   // no copy constructor yet: the compiler generates one
    s1.print();
    s2.print();
    s2.setGrade(0, 4);
    s1.print();        // did s1 change?
}                      // s2, then s1 are destroyed here

The experiment

SHALLOW COPY                 DEEP COPY
s1 ----+                     s1 --------> block A
       +----> block          s2 --------> block B
s2 ----+

Predict, then check. This version has no destructor, so it leaks, but it never deletes anything twice:

#include <iostream>
using namespace std;
class Student {
public:
    int* grades;
    int noGrades;
    Student(int n) : grades(new int[n]), noGrades(n) {
        for (int i = 0; i < n; i++) grades[i] = 5;
    }
    // no destructor here: this version leaks, but it never deletes twice
};
int main() {
    Student s1(2);
    Student s2 = s1;
    s2.grades[0] = 10;
    cout << s1.grades[0] << " " << (s1.grades == s2.grades);
}

Implement the Rule of Three

Student(const Student& s) {
    name = new char[strlen(s.name) + 1];
    strcpy(name, s.name);
    noGrades = s.noGrades;
    grades = new int[noGrades];
    for (int i = 0; i < noGrades; i++) grades[i] = s.grades[i];
}

Student& operator=(const Student& s) {
    if (this == &s) return *this;
    delete[] name;
    delete[] grades;
    name = new char[strlen(s.name) + 1];
    strcpy(name, s.name);
    noGrades = s.noGrades;
    grades = new int[noGrades];
    for (int i = 0; i < noGrades; i++) grades[i] = s.grades[i];
    return *this;
}

Predict, then check. Which line prints copy and which prints assign?

#include <iostream>
using namespace std;
class Student {
public:
    Student() {}
    Student(const Student&) { cout << "copy" << endl; }
    Student& operator=(const Student&) { cout << "assign" << endl; return *this; }
};
int main() {
    Student s1;
    Student s2 = s1;
    Student s3;
    s3 = s1;
    Student s4(s1);
}

Mandatory questions

1. What is a shallow copy?
2. What is a deep copy?
3. When is the copy constructor called?
4. What does the compiler-generated copy constructor do?
5. What is the difference between Student s2 = s1; and s2 = s1;?
6. Why does operator= usually return *this?

Minimum task

#include <iostream>
#include <cstring>
using namespace std;

class Student {
  char* name;
  int* grades;
  int noGrades;
public:
  Student(const char* n, const int* g, int count) {
      name = new char[strlen(n) + 1];
      strcpy(name, n);
      noGrades = count;
      grades = new int[noGrades];
      for (int i = 0; i < noGrades; i++) grades[i] = g[i];
  }
  // TODO: copy constructor (deep copy)
  // TODO: operator= (self-assignment check, free, copy, return *this)
  ~Student() {
      delete[] name;
      delete[] grades;
  }
  void setGrade(int i, int value) { grades[i] = value; }
  void print() const {
      cout << name << ":";
      for (int i = 0; i < noGrades; i++) cout << " " << grades[i];
      cout << endl;
  }
};

int main() {
  int g[] = {8, 9, 7};
  Student s1("Ana", g, 3);
  Student s2 = s1;
  s2.setGrade(0, 4);
  int h[] = {10};
  Student s3("Dan", h, 1);
  s3 = s1;
  s3.setGrade(1, 5);
  s3 = s3;
  s1.print();   // expected: Ana: 8 9 7
  s2.print();   // expected: Ana: 4 9 7
  s3.print();   // expected: Ana: 8 5 7
}

Requirement change

New requirement: add void addGrade(int value), which grows the grades array by one element. Then copy a student and add a grade to the copy. Does the original change? What would go wrong if addGrade forgot to delete[] the old array, and what if it forgot to update noGrades?

Code in repository: L05

Romanian version