Saptamana 05 / 14 Programare Orientata Obiect

Seminar 5 - Copierea obiectelor si Regula celor trei

Copiem un obiect care detine memorie pe heap, vedem cum copia generata de compilator imparte aceeasi memorie, apoi scriem destructorul, constructorul de copiere si operator= care fac copiile independente.

Plan (90 min)

Programul de pornire

Clasa de mai jos detine doua blocuri pe heap: numele si notele. Are destructor, dar nu are constructor de copiere si nici operator=. Citeste codul, apoi ruleaza-l.

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

class Student {
    char* nume;
    int* note;
    int nrNote;
public:
    Student(const char* n, const int* v, int nr) {
        nume = new char[strlen(n) + 1];
        strcpy(nume, n);
        nrNote = nr;
        note = new int[nrNote];
        for (int i = 0; i < nrNote; i++) note[i] = v[i];
    }
    ~Student() {
        cout << "~Student elibereaza numele de la " << (void*)nume << endl;
        delete[] nume;
        delete[] note;
    }
    void setNota(int i, int valoare) { note[i] = valoare; }
    void afisare() const {
        cout << nume << ":";
        for (int i = 0; i < nrNote; i++) cout << " " << note[i];
        cout << "   nume la " << (void*)nume << ", note la " << note << endl;
    }
};

int main() {
    int v[] = {8, 9, 7};
    Student s1("Ana", v, 3);
    Student s2 = s1;   // inca nu avem constructor de copiere: il genereaza compilatorul
    s1.afisare();
    s2.afisare();
    s2.setNota(0, 4);
    s1.afisare();      // s-a schimbat s1?
}                      // aici se distrug s2, apoi s1

Experimentul

COPIERE SUPERFICIALA         COPIERE IN ADANCIME
s1 ----+                     s1 --------> bloc A
       +----> bloc           s2 --------> bloc B
s2 ----+

Prezice, apoi verifica. Varianta asta nu are destructor, deci are memory leak, dar nu sterge nimic de doua ori:

#include <iostream>
using namespace std;
class Student {
public:
    int* note;
    int nrNote;
    Student(int n) : note(new int[n]), nrNote(n) {
        for (int i = 0; i < n; i++) note[i] = 5;
    }
    // fara destructor: varianta asta are memory leak, dar nu sterge nimic de doua ori
};
int main() {
    Student s1(2);
    Student s2 = s1;
    s2.note[0] = 10;
    cout << s1.note[0] << " " << (s1.note == s2.note);
}

Implementeaza Regula celor trei

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

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

Prezice, apoi verifica. Ce linie afiseaza copiere si ce linie afiseaza atribuire?

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

Intrebari obligatorii

1. Ce este copierea superficiala (shallow copy)?
2. Ce este copierea in adancime (deep copy)?
3. Cand se apeleaza constructorul de copiere?
4. Ce face constructorul de copiere generat de compilator?
5. Care este diferenta dintre Student s2 = s1; si s2 = s1;?
6. De ce operator= intoarce de obicei *this?

Sarcina minima

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

class Student {
  char* nume;
  int* note;
  int nrNote;
public:
  Student(const char* n, const int* v, int nr) {
      nume = new char[strlen(n) + 1];
      strcpy(nume, n);
      nrNote = nr;
      note = new int[nrNote];
      for (int i = 0; i < nrNote; i++) note[i] = v[i];
  }
  // TODO: constructor de copiere (copiere in adancime)
  // TODO: operator= (verificare auto-atribuire, eliberare, copiere, return *this)
  ~Student() {
      delete[] nume;
      delete[] note;
  }
  void setNota(int i, int valoare) { note[i] = valoare; }
  void afisare() const {
      cout << nume << ":";
      for (int i = 0; i < nrNote; i++) cout << " " << note[i];
      cout << endl;
  }
};

int main() {
  int v[] = {8, 9, 7};
  Student s1("Ana", v, 3);
  Student s2 = s1;
  s2.setNota(0, 4);
  int w[] = {10};
  Student s3("Dan", w, 1);
  s3 = s1;
  s3.setNota(1, 5);
  s3 = s3;
  s1.afisare();   // asteptat: Ana: 8 9 7
  s2.afisare();   // asteptat: Ana: 4 9 7
  s3.afisare();   // asteptat: Ana: 8 5 7
}

Provocare

Cerinta noua: adauga void adaugaNota(int valoare), care mareste vectorul de note cu un element. Copiaza apoi un student si adauga o nota copiei. Se schimba originalul? Ce s-ar strica daca adaugaNota ar uita delete[] pentru vectorul vechi, si ce daca ar uita sa actualizeze nrNote?

Codul din repository: S05

Varianta in engleza