Unable to avoid copying while pushing objects with copy-construcor into a vector

Question

I'm trying to avoid copying with emplace_back() and reserve(). But when I've tried to do it, i caught myself getting 3 copies for reason i cannot really understand. reserve() actually helps to avoid copying, but emplace_back() actually does nothing with it (works the same way as push_back() in this case). Here's the code:

struct Vertex
{
    size_t x, y, z;

    Vertex(size_t x, size_t y, size_t z)
    {
        this->x = x;
        this->y = y;
        this->z = z;
    }

    Vertex(const Vertex& v)
        : x(v.x), y(v.y), z(v.z)
    {
        std::cout << "\nCOPIED!\n";
    }
};

int main()
{
    std::vector<Vertex> vert;

    vert.reserve(3);
    vert.emplace_back(Vertex(1, 2, 3));
    vert.emplace_back(Vertex(4, 5, 6));
    vert.emplace_back(Vertex(7, 8, 9));

    return 0;
}

The output is 3 times 'COPIED!'. Well i tried to something like this:

    vert.emplace_back(std::move(Vertex(1, 2, 3)));
    vert.emplace_back(std::move(Vertex(4, 5, 6)));
    vert.emplace_back(std::move(Vertex(7, 8, 9)));

to convert my objects into r-values, but again i got 3 times 'COPIED!'.

Then i tried to push the same object 3 times with std::move and without and again got the same result:

    Vertex vertex(1, 2, 3);
    vert.emplace_back(vertex);
    vert.emplace_back(vertex);
    vert.emplace_back(vertex);

or

    Vertex vertex(1, 2, 3);
    vert.emplace_back(std::move(vertex));
    vert.emplace_back(std::move(vertex));
    vert.emplace_back(std::move(vertex));

I don't understand what am i doing wrong. I use MSVS 2022 Preview C++14. Also i tried to do it on C++14/17/20 and same result. Is there a way to get rid of all of the copies? Or maybe i understand situation wrong?

Make it `vert.emplace_back(1, 2, 3);`. The whole point of `emplace_back` is that you can pass in parameters to the object's constructor that the vector can use to construct the object in place, rather than an object instance that will then have to be copied. The way you use it, it's no different from `push_back` — Igor Tandetnik, Oct 17 '21 at 13:13
You cannot `std::move` your object as it doesn't have a move-constructor. — tkausl, Oct 17 '21 at 13:13
You use `std::move`, but because you have user-declared copy constructor, you have blocked possibility of compiler creating move constructor for your class. You need to declare a move constructor (e.g. with `Vertex(Vertex&&) = default;`). — Yksisarvinen, Oct 17 '21 at 13:13
Even if there was a move-constructor, there are no managed resources for the class member variables, so there is nothing to move. So in this case, a move does the same thing as a copy. — Eljay, Oct 17 '21 at 13:16

eerorika · Accepted Answer · 2021-10-17T13:49:24.720

std::move isn't useful here. The temporary Vertex object is already a prvalue, so casting it to an xvalue doesn't change anything. The class has no move constructor, so copy initialisation cannot move; it has to copy. The implicit move constructor has been inhibited by the user defined copy constructor. Although, the move constructor couldn't be any faster than the copy constructor for this class anyway.

The way that emplace_back works is that it forwards the arguments to the constructor of the element. If the argument that you pass is an object of the element type, then you invoke the constructor that accepts another instance of the class - that is the copy constructor (or the move constructor for classes that have it).

Instead of creating a temporary Vertex object, and passing it as an argument to emplace_back, you should pass the three size_t objects that can be forwarded to the constructor Vertex(size_t, size_t, size_t). This way you can avoid copying (and moving) of the Vertex object entirely:

vert.emplace_back(1, 2, 3);
vert.emplace_back(4, 5, 6);
vert.emplace_back(7, 8, 9);

score 1 · Answer 2 · answered Oct 17 '21 at 13:17

Since you provided a custom copy constructor for struct Vertex, no move constructor was automatically generated. Attempting to move this struct will use the copy constructor, as you observed.

Add a custom move constructor:

Vertex(Vertex &&v)
    : x(std::move(v.x)), y(std::move(v.y)), z(std::move(v.z))
{
    std::cout << "MOVED!\n";
}

But note that other than for printing, here you don't need neither custom copy nor move constructor. The implicitly generated ones should be enough.

std::move(Vertex(1, 2, 3))

std::move doesn't change anything here, because Vertex(1, 2, 3) is already an rvalue.

but emplace_back() .... works the same way as push_back() in this case

Yes. For it to make a difference, you need to pass constructor arguments directly into it, as mentioned in @eerorika's answer:

vert.emplace_back(1, 2, 3);

This will get rid of the copy/move, by constructing the object directly in the vector.

score 0 · Answer 3 · answered Oct 17 '21 at 13:54

0

Make it a POD (Plain Old Data) by adding a default constructor :

struct Vertex
{
    size_t x, y, z;

    Vertex() = default;

    Vertex(size_t xx, size_t yy, size_t zz) : x{xx}, y{yy}, z{zz} {}
};

answered Oct 17 '21 at 13:54

grigouille

511
3
14

Unable to avoid copying while pushing objects with copy-construcor into a vector

3 Answers3