Copy constructor vs assignment operator with STL vector

Question

Having this class:

class A
{
    int number;
    int number2;
public:
    A(int _number):number(_number),number2(0)
    {
        cout<<"Normal constructor\n";
    }
    A()
    {
        cout<<"Default constructor\n";
    }

    A(const A& source)
    {
        number = source.number;
        number2 = source.number2;
        cout<<"Copy constructor\n";
    }

    A & operator=(const A& source)
    {
        number = source.number;
        number2 = source.number2;
        cout<<"Assignment operator\n";
        return *this;
    }
};

If vector<A> obj {1,2,3} is created, normal constructor is called three times because it is not declared as explicit and therefore it is used as a converting constructor. Then the copy constructor is called three times.

Is there any way a vector can be declared and instantiated while skipping the copying operation?

If vector<A> obj_1; is executed, an empty vector which can hold objects of type A is created - no constructors called, but the object exists.

Why there is no constructor called?
Did I declared the object such as it is fully workable?

From this link:

A copy constructor is used to initialize a previously uninitialized object from some other object's data.
An assignment operator is used to replace the data of a previously initialized object with some other object's data.

Doing obj_1 = obj, if my obj_1 was previously initialized results in calling the copy constructor instead of operator= function inside my class A as I was expecting?

Also, inside vector there is already an operator= function. How can I know when will be called each?

vector<A> obj {1,2,3};
vector<A> obj_1;
obj_1 = obj;  // Why copy constructor called instead of function operator= inside my class

`vector obj_1;` is an empty vector. That's why there are no constructor calls. — NathanOliver, Apr 15 '20 at 15:28
How can I declare an empty thing ? When I declare an `int a`, `a` is empty but there is data — Cătălina Sîrbu, Apr 15 '20 at 15:29
Because a vector uses dynamic asllocation. Basically what you have is a wrapper for an `A*`. If you do `A* foo;` you have the `A*`, but no `A`'s were created. — NathanOliver, Apr 15 '20 at 15:30
@JesperJuhl what are you trying to tell me ? That I should have choose the initializing list? — Cătălina Sîrbu, Apr 15 '20 at 15:37

score 3 · Accepted Answer · answered Apr 15 '20 at 15:40

3

Is there any way a vector can be declared and instantiated while skipping the copying operation?

No. When you do vector<A> obj {1,2,3} the compiler creates a std::initializer_list<A> from the values provided. That std::initializer_list creation is the reason you see the three normal constructor calls. The vector then has to copy those elements because the underlying storage for those elements is const. There is no was to get around that with list initialization. Even vector<A> obj {A(1),A(2),A(3)} would still cause copies.

If you don't want that then one thing you can do is create storage for the elements using reserve, and then use emplace_back to directly construct the objects in the vector like

vector<A> obj;
obj.reserve(3);
for (int i = 1; i < 4, ++i)
    obj.emplace_back(i);

Doing obj_1 = obj, if my obj_1 was previously initialized results in calling the copy constructor instead of operator= function inside my class A as I was expecting?

This is because obj_1 is empty. Since it is empty, there is no element to call the assignment operator on. Instead what it does is create elements in obj_1 that are copies of obj and the most efficient way to do that is to just call the copy constructor instead of default constructing the objects and then assigning to them.

If you had

vector<A> obj {1,2,3};
vector<A> obj_1 {3, 4, 5};
obj_1 = obj;

Instead then you would see the assignment operator be used instead since there are objects to actually assign to.

answered Apr 15 '20 at 15:40

NathanOliver

171,901
28
288
402

This is unclear to me. How can `obj_1` be empty. Didn't I declared it and this means it has some place in memory and some value ? even if `nullptr` or something simillar (default underlying data type - in this case as `vector` use dynamic allocation I think `nullptr` should be the correct value)? **I didn't do** `vector obj_1 = obj` _(I'm not sure is correct though)_ – Cătălina Sîrbu Apr 15 '20 at 15:45
@CătălinaSîrbu It's empty as in there are no elements inside it. If you called `size()`, it would return `0`. There is a vector there, and when you do `obj_1 = obj; ` it calls vector's `operator =`, it's just that vector's `operator =` is smart enough to know that it can call the copy constructor when it needs to create elements in the vector to assign to them. – NathanOliver Apr 15 '20 at 15:49
Ok so if I would like my class function `operator=` to be called, which should be the state of my `vector`? Should it contains at least one element of type `A` initialized to a value? – Cătălina Sîrbu Apr 15 '20 at 15:51
@CătălinaSîrbu It would need to have as many elements in it as the source vector. That would look like `vector obj {1,2,3}; vector obj_1(obj.size()); // this creates empty objects in the vector; obj_1 = obj;` Then you would see the assignment operator used for all of the elements. This is something that you don't want to do however. It's more efficient to just do what you have and allow the copy constructor to be used to create the elements in `obj_1` – NathanOliver Apr 15 '20 at 15:54
If `vector obj {1,2,3};` is followed by ` vector obj_1 {1,2};` and by `obj_1 = obj;`: why there is the `copy constructor` called three times? _I was expecting `copy constructor` to be called only once (for the last inexistent element), and `operator=` function two time (for the first two elements that are already existent)_ – Cătălina Sîrbu Apr 15 '20 at 15:57
@CătălinaSîrbu In that case `obj_1` needs to grow so it has enough space. Instead of growing, which copies the elements in the vector, and then doing the assignment, the vector just allocates new storage and copy constructs all of the elements from the source vector. That's the most efficient way to do it. – NathanOliver Apr 15 '20 at 16:08

Copy constructor vs assignment operator with STL vector

1 Answers1