Overload the assignment operator (deep copy)

In C++, a deep copy is a type of copy that creates a new object and copies all the data from the original object into the new object, including any data that is pointed to by the original object's pointers.

When you make a deep copy of an object, you create a new object with its own memory space, independent of the original object. This means that any changes made to the original object will not affect the new object, and vice versa.

A deep copy is often used when working with objects that have dynamically allocated memory, such as objects created on the heap using the new operator. In this case, a simple copy of the object using the default copy constructor or assignment operator would result in both objects pointing to the same memory location, which can cause problems if one object is modified.

Here is an example of a deep copy:

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

class Person {
public:
    // 2 argument constructor
    Person(const string& name, int age);
    // Copy constructor
    Person(const Person& other);
    //Destructor
    ~Person();
    // Functions
    void introduce();
    void setID(int newID); // Setter for id
private:
    string name;
    int age;
    // Pointer to dynamically allocated memory
    // it creates a new dynamic memory allocation (heap)
    // and copies the value from the original Person.
    int* id;
};

Person::Person(const string& name, int age) {
    this->name = name;
    this->age = age;
    // Allocate memory for id and dynamically allocates memory
    // for id and initializes it with 12345.
    this->id = new int(12345);
}

Person::Person(const Person& other) {
    this->name = other.name;
    this->age = other.age;
    // Allocate - creates a new dynamic memory allocation (heap)
    // and copies the value from the original Person.
    this->id = new int(*other.id);
}

Person::~Person() {
    delete id; // Deallocate memory for id
}

void Person::introduce() {
    cout << "Hi, my name is " << name << " and I am " << age << " years old. My ID is " << *id << "." << endl;
}

void Person::setID(int newID) {
    // Set the value of id
    *id = newID;
}

int main() {
    Person personOne("Kevin", 39);
    // Use copy constructor to create new object personTwo
    Person personTwo = personOne;
    
    personOne.introduce();
    personTwo.introduce();
    
    cout << endl;
    cout << "Now lets change the ID of personTwo (pointer)" << endl;
    
    // Change ID of personOne using the setter
    personOne.setID(54321);
    
    personOne.introduce();
    personTwo.introduce();
    
    return 0;
}

This C++ code defines a Person class with attributes for name, age, and id.

• name and age are straightforward - a string for the name and an int for the age.

• id is a pointer to an integer, which is dynamically allocated on the heap.

The Person class defines the following:

1. A constructor Person::Person(const string& name, int age): This initializes a Person object with a name and age, and dynamically allocates memory for id and initializes it with 12345.

2. A copy constructor Person::Person(const Person& other): This is invoked when an existing Person object is copied. It initializes a new Person object with the same name and age as the original. For id, it creates a new dynamic memory allocation (heap) and copies the value from the original Person.

3. A destructor Person::~Person(): This is invoked when a Person object is destroyed (goes out of scope or is deleted). It deallocates the dynamic memory assigned to id to prevent memory leaks.

4. A introduce function void Person::introduce(): This prints the name, age, and id of the Person.

5. A setter function void Person::setID(int newID): This sets the value of id for the Person.

In the main() function:

• Person personOne("Kevin", 39) creates a Person object named personOne.

• Person personTwo = personOne uses the copy constructor to create a new Person object personTwo that's a copy of personOne.

• Then, it prints the information of personOne and personTwo, showing that both have the same name, age, and id.

• It changes the id of personOne and prints the information again. You'll see that personOne's id has changed, but personTwo's id remains the same, demonstrating that the copy constructor made a separate copy of the id. This concept is often referred to as deep copying in C++.