Demo - Overload the assignment operator (deep copy)

Here is an example of a deep copy:

Person.h - This is the header file where the class declaration will be placed.

// Person.h
#ifndef PERSON_H
#define PERSON_H

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

class Person {
public:
    // 2 argument constructor
    Person(const std::string& name, int age);
    // Copy constructor
    Person(const Person& other);
    // Assignment operator
    Person& operator=(const Person& other);
    // Destructor
    ~Person();
    // Functions
    void introduce();
    void setID(int newID); // Setter for id

private:
    string name;
    int age;
    int* id; // Pointer to dynamically allocated memory
};

#endif // PERSON_H

Person.cpp - This is the source file where the class definitions (implementation) will be placed.

// Person.cpp
#include "Person.h"

Person::Person(const std::string& name, int age) : name(name), age(age) {
    id = new int(12345); // Allocate memory for id
}

Person::Person(const Person& other) : name(other.name), age(other.age) {
    id = new int(*other.id); // Allocate memory and copy id
}

Person& Person::operator=(const Person& other) {
    if (this != &other) { // Avoid self-assignment
        name = other.name;
        age = other.age;

        delete id; // Deallocate existing id memory
        id = new int(*other.id); // Allocate new memory and copy id
    }
    return *this;
}

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) {
    *id = newID; // Set the value of id
}

main.cpp - The file to use the Person class.

// main.cpp
#include "Person.h"

int main() {
    Person personOne("Kevin", 39);
    Person personTwo = personOne; // Use copy constructor
    
    personOne.introduce();
    personTwo.introduce();
    
    cout << endl << "Now lets change the ID of personOne " << endl;
    
    personOne.setID(54321); // Change ID of personOne
    
    personOne.introduce();
    personTwo.introduce(); // personTwo will have the original ID
    
    // Demonstrating assignment operator
    Person personThree("Alice", 25);
    personThree = personOne; // Use assignment operator
    personThree.introduce(); // personThree will have the same ID as personOne
    
    return 0;
}

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++.