What 's the difference between assignment operator and copy constructor?

In C++, both the assignment operator and the copy constructor are used for copying objects, but they are applied in different contexts and operate differently.

Copy Constructor

The copy constructor is used to create a new object that is a copy of an existing object. It is invoked in the following situations:

• When a new object is created and initialized using an existing object of the same type.
• When an object is passed by value to a function.
• When an object is returned by value from a function.

Example:

cpp
class Example {
public:
    int a;
    Example(int x) : a(x) {}  // constructor
    Example(const Example& other) { // copy constructor
        a = other.a;
    }
};

int main() {
    Example obj1(10);         // calls constructor
    Example obj2 = obj1;      // calls copy constructor
    return 0;
}

In this example, obj2 is created via the copy constructor, with its initial value derived from obj1.

Assignment Operator

The assignment operator is used to copy the state of an existing object to another existing object. This typically occurs after both objects have been created.

Example:

cpp
class Example {
public:
    int a;
    Example(int x) : a(x) {}  // constructor
    Example& operator=(const Example& other) { // assignment operator
        if (this != &other) { // avoid self-assignment
            a = other.a;
        }
        return *this;
    }
};

int main() {
    Example obj1(10);        // calls constructor
    Example obj2(20);        // calls constructor
    obj2 = obj1;             // calls assignment operator
    return 0;
}

In this example, both obj1 and obj2 are independently created. Subsequently, we use the assignment operator to copy the state of obj1 to obj2.

Summary

In summary, the copy constructor is called when a new object is created to initialize it as a copy of another object; whereas the assignment operator is used to copy data between two existing objects. The assignment operator must handle self-assignment and typically returns a reference to itself.