赋值运算符作为副本构造函数

Question

Assignment operator can be used to copy the value of one object to another instead of using copy constructor,then why we required a copy constructor?

class example  
{
    int data;
public:
    example()
    {
    }

    example(int x)
    {
        data = x;
    }
};

int main()
{
    example a(50);
    example a(b);
    //same can be done with the assignment operator
    //b = a;
    return 0;
}

Answer 1

Because at the point of calling a copy constructor, the object being copied to doesn't yet exist.

An assignment operator assigns the value of another object to one that does exist.

Devices such as member initialisation can be used with a copy constructor, but are not available on assignment. Furthermore it's possible to create a const object using a copy constructor.

Furthermore, the assignment operator typically returns a reference to self.

So a copy constructor and the assignment operator probably will leave the mutated object in an identical state, but it doesn't necessarily have to be the case.

Answer 2

As Bathsheba already said: A copy constructor creates a new object, an assignment operator assigns values to an already existing object. One needs to construct a new object, the other needs to handle whatever happens if you assign the values from one object to another. Take this example:

class Foo
{
  public:
    Foo(int x) { someValue = x; };
    int getValue() const { return someValue; };
  private:
    int someValue;
}

class Bar
{
  public:
    Bar(int y)
    {
        myFoo = new Foo(y);
        myValue = y + 1;
        myInitDone = true;
    };

    Bar(const Bar& other)
    {
        //myFoo was not yet initalized, so no need to clean it up
        myFoo = new Foo(other.myFoo->getValue()); 
        myValue = other.myValue;
        myInitDone = true;
    }

    Bar& operator=(const Bar& other)
    {
        delete myFoo; // If we don't clean up myFoo here we leak memory
        myFoo = new Foo(other.myFoo->getValue());
        myValue = other.myValue;
        // myInitDone is only set during construction due to [reason]
    }

  private:
    Foo* myFoo;
    int myValue;
    bool myInitDone;
}

The copy constructor needs to set myInitDone (which is only done during constuction because [insert reason here] ), while the assigment operator needs to clean up myFoo or it will leak memory.