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

Question

I don't understand the difference between assignment constructor and copy constructor in C++. It is like this:

class A {
public:
    A() {
        cout << "A::A()" << endl;
    }
};

// The copy constructor
A a = b;

// The assignment constructor
A c;
c = a;

// Is it right?

I want to know how to allocate memory of the assignment constructor and copy constructor?

Labyrinthine

related FAQ – Stephanistephania

Answer 1

A copy constructor is used to initialize a previously uninitialized object from some other object's data.

A(const A& rhs) : data_(rhs.data_) {}

For example:

A aa;
A a = aa;  //copy constructor

An assignment operator is used to replace the data of a previously initialized object with some other object's data.

A& operator=(const A& rhs) {data_ = rhs.data_; return *this;}

For example:

A aa;
A a;
a = aa;  // assignment operator

You could replace copy construction by default construction plus assignment, but that would be less efficient.

(As a side note: My implementations above are exactly the ones the compiler grants you for free, so it would not make much sense to implement them manually. If you have one of these two, it's likely that you are manually managing some resource. In that case, per The Rule of Three, you'll very likely also need the other one plus a destructor.)

Tadtada

Just a note: Nowadays (C++11 onward), they can be explicitly defaulted with =default;. – Tailpipe

@Tailpipe It's also important to mention that, when adhering to classifications that require trivial constructors, you must = default them where a default ctor is needed: simply implementing an empty body by ourselves still counts as a user-defined ctor and thus (on a Standardese level) isn't trivial and disqualifies the type from classifications that require a trivial ctor. – Breaker

@Tadtada Can I say that in case copy constructor is not used and instead assignment operator is used, object is created first by calling constructor either with arguments or without arguments and then assignment operator is used and new values are assigned based on RHS. In case copy constructor is used, still same constructor will be called, but values used for initialization is from other object. – Efficacy

@Rajesh: I'm confused about what you are asking, and my feeling is that is because you are also confused. :) Will you try again to explain what you are talking about? – Tadtada

if you overload the = operator, you could still do whatever you wanted to do in your copy constructor? – Footsie

@CătălinaSîrbu: You could. They are two independent functions. – Tadtada

But WHY is it less efficient? That’s what I’m having a hard time finding explanation of anywhere. – Nemathelminth

@LiamClink: Did you ask why two operations are less efficient than one operation?? – Tadtada

@Tadtada The copy constructor IS two operations. Initialization and assignment, instead of default construction and assignment. That’s why I didn’t get why one would be more efficient than the other – Nemathelminth

@LiamClink: That is wrong. Initialization means to turn a chunk of raw memory into a well-formed object by writing sensible bytes into that chunk of memory. Copy-construction allows you to write the correct bytes right from the start, rather than first default-initializing the object and then having to override it via assignment. – Tadtada

Answer 2

The difference between the copy constructor and the assignment operator causes a lot of confusion for new programmers, but it’s really not all that difficult. Summarizing:

• If a new object has to be created before the copying can occur, the copy constructor is used.
• If a new object does not have to be created before the copying can occur, the assignment operator is used.

Example for assignment operator:

Base obj1(5); //calls Base class constructor
Base obj2; //calls Base class default constructor
obj2 = obj1; //calls assignment operator

Example for copy constructor:

Base obj1(5);
Base obj2 = obj1; //calls copy constructor

Innermost

Would it be fair to say that an assignment operator effectively combines the destruction of an old object with the creation of a new one, but with the provisos that (1) if one of the steps in the destruction of the old object would be undone by one of the steps in the construction of the new one, both steps may be omitted; (2) assignment operators shouldn't do bad things if an object is assigned to itself. – Enclave

why doing vector <A> v3 and then v3 = v2 (where v2 is a previously declared and containing elements vector<A>) calls my explicit A's copy constructor instead the operator= ? I was expecting operator= to be called instead of the copy constructor because my v3 object was already declared at the time where I did the assignment – Footsie

Answer 3

The first is copy initialization, the second is just assignment. There's no such thing as assignment constructor.

A aa=bb;

uses the compiler-generated copy constructor.

A cc;
cc=aa;

uses the default constructor to construct cc, and then the *assignment operator** (operator =) on an already existing object.

I want know how to allocate memory of the assignment constructor and copy constructor?

IDK what you mean by allocate memory in this case, but if you want to see what happens, you can:

class A
{
public :
    A(){ cout<<"default constructor"<<endl;};
    A(const A& other){ cout<<"copy constructor"<<endl;};
    A& operator = (const A& other){cout <<"assignment operator"<<endl;}
};

I also recommend you take a look at:

Why is copy constructor called instead of conversion constructor?

What is The Rule of Three?

Beg

Answer 4

In a simple words,

Copy constructor is called when a new object is created from an existing object, as a copy of the existing object. And assignment operator is called when an already initialized object is assigned a new value from another existing object.

Example-

t2 = t1;  // calls assignment operator, same as "t2.operator=(t1);"
Test t3 = t1;  // calls copy constructor, same as "Test t3(t1);"

Machute

Answer 5

the difference between a copy constructor and an assignment constructor is:

1. In case of a copy constructor it creates a new object.(<classname> <o1>=<o2>)
2. In case of an assignment constructor it will not create any object means it apply on already created objects(<o1>=<o2>).

And the basic functionalities in both are same, they will copy the data from o2 to o1 member-by-member.

Reba

Answer 6

What @Luchian Grigore Said is implemented like this

class A
{
public :
    int a;
    A(){ cout<<"default constructor"<<endl;};
    A(const A& other){ cout<<"copy constructor"<<endl;};
    A& operator = (const A& other){cout <<"assignment operator"<<endl;}
};

void main()
{
    A sampleObj; //Calls default constructor
    sampleObj.a = 10;

    A copyConsObj  = sampleObj; //Initializing calls copy constructor

    A assignOpObj; //Calls default constrcutor
    assignOpObj = sampleObj; //Object Created before so it calls assignment operator
}

OUTPUT

---

default constructor

---

copy constructor

---

default constructor

---

assignment operator

---

Saleswoman

Answer 7

I want to add one more point on this topic. "The operator function of assignment operator should be written only as a member function of the class." We can't make it as friend function unlike other binary or unary operator.

Androgynous

Answer 8

Something to add about copy constructor:

• When passing an object by value, it will use copy constructor

• When an object is returned from a function by value, it will use copy constructor

• When initializing an object using the values of another object(as the example you give).

Elmore