Deep copying and Conversion

Shallow and Deep Copying

An object is copied when:

1. Constructing new object from existing

2. Passing parameter by value

3. Returning by value

4. Assigning existing to existing.

Cases 1-3 are handled by copy constructor;

Case 4 is handled by assignment operator.

By default, both do shallow copy.

Rule of 3

When you need to make a deep copy of an object, you need to define all of these:

1. Copy constructor 2. Destructor 3. Operator =

Example of Deep Copy

//@author Erel Segal-Halevi
#include <iostream>
using namespace std;

class IntList {
private:
    int* theInts;
    uint numInts;

public:
    IntList(uint newNumInts):
            numInts(newNumInts),
            theInts(new int[newNumInts]){  }

    // conversion constructor
    IntList(const string& other):
            numInts(2),
            theInts(new int[2]){
        cout << "converting string to IntList" << endl;
    }

    IntList(const IntList& other):
    // IntList(IntList other):
            IntList(other.numInts){
        cout << "copy constructor doing deep copy" << endl;
        for (uint i=0; i<numInts; ++i)
            theInts[i] = other.theInts[i];
    }

    IntList& operator=(const IntList& other) {
        if (this==&other)
            return *this;
        cout << "assignment operator doing deep copy..." << endl;

        if (other.numInts!=this->numInts) {
            delete[] theInts;
            theInts = new int[other.numInts]; // init
            numInts = other.numInts;
        }

        for (uint i=0; i<numInts; ++i)
            theInts[i] = other.theInts[i];
        return *this;
    }

    ~IntList() {
        delete[] theInts;
    }

    int size() const {
        return numInts;
    }

    void operator=(int value) {
        cout << "filling with "<<value<<"..."<<endl;
        for (uint i=0; i<this->numInts; ++i)
            theInts[i] = value;
    }

    int operator[](uint index) const {
        return theInts[index];
    }

    int& operator[](uint index) {
        return theInts[index];
    }

    void operator()(const IntList& other) {
        cout << "hahaha" << endl;
    }
};

/**
 * If you pass a parameter by value -
 *    the compiler will call the copy ctor
 */
int sum(const IntList& list) {
    int result=0;
    for (int i=0; i<list.size(); ++i) {
        result += list[i];
    }
    // list[5] = 88;
    return result;
}

int main() {
    // int a,b,c;    a = b = c; // Chaining
    IntList list1{10};
    cout << "list1[5] = " << list1[5] << endl;
    list1 = 1;
    cout << "list1[5] = " << list1[5] << endl << endl;
    cout << "sum(list1) = " << sum(list1) << endl;
    cout << "list1[5] = " << list1[5] << endl << endl;
    cout << "---" << endl;

    IntList list2{list1};     // calls copy ctor
    // IntList list2 (list1);  // calls copy ctor
    // IntList list2 = list1;  // calls copy ctor
    cout << "list1[5] = " << list1[5] << endl;
    cout << "list2[5] = " << list2[5] << endl;
    list2 = 2;
    cout << "list1[5] = " << list1[5] << endl;
    cout << "list2[5] = " << list2[5] << endl << endl;

    IntList list3{20};
    list3 = list1;   // operator=
}

list1[5] = 0
filling with 1...
list1[5] = 1

sum(list1) = 10
list1[5] = 1

---
copy constructor doing deep copy
list1[5] = 1
list2[5] = 1
filling with 2...
list1[5] = 1
list2[5] = 2

assignment operator doing deep copy...

IntList& operator=() returning a reference allows us to chain a=b=c

Conversions of types

Implicit casting

Vector(size_t length) // ctor
...
int sum(const Vector& v) // function
...
int i=3;
sum(i);

sum(i) is same as sum(Vector(i)). Did the user really wanted this?

explicit keyword

Prevents undesired conversion

explicit Vector(size_t length) // ctor
...
int sum(const Vector& v) // function
...
int i=3;
sum(i); // Won�t compile
sum(Vector{i}); // compiles