When will adding a move constructor and a move assignment operator really start make a difference?

Question

Considering the high quality of today's compilers regarding return value optimization (both RVO and NRVO), I was wondering at what class complexity it's actually meaningful to start adding move constructors and move assignment operators.

For instance, for this really_trivial class, I just assume that move semantics cannot offer anything more than RVO and NRVO already does when copying around instances of it:

class really_trivial
{
    int first_;
    int second_;

public:

    really_trivial();
    ...
};

While in this semi_complex class, I'd add a move constructor and move assignment operator without hesitation:

class semi_complex
{
    std::vector<std::string> strings_;

public:

    semi_complex(semi_complex&& other);
    semi_complex& operator=(semi_complex&& other);
    ...
};

So, at what amount and of what kinds of member variables does it start making sense to add move constructors and move assignment operators?

ltjax · Accepted Answer · 2011-01-18 17:13:47Z

9

It is already meaningful for purely semantic reasons, even if you keep the optimization-aspects out completely. Just imagine the case where a class does not/cannot implement copying. For example boost::scoped_ptr cannot be copied, but it can be moved!

edited Jan 18, 2011 at 17:13

answered Jan 18, 2011 at 13:00

ltjax

16.1k3 gold badges43 silver badges64 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Howard Hinnant · Accepted Answer · 2011-01-23 19:34:24Z

7

In addition to the excellent answers already given, I would like to add a few forward-looking details:

There are new rules in the latest C++0x draft for automatically generating a move constructor and move assignment operator. Although this idea is not entirely new, the latest rules have only been in the draft since Oct. 2010, and not yet widely available in compilers.

If your class does not have a user-declared copy constructor, copy assignment operator, move constructor, move assignment operator and destructor, the compiler will provide defaulted move constructor and move assignment operator for you. These default implementations will simply member-wise move everything.

You can also explicitly default your move members:

semi_complex(semi_complex&&) = default;
semi_complex& operator=(semi_complex&&) = default;

Note that if you do so, you will implicitly inhibit copy semantics unless you explicitly supply or default the copy constructor and copy assignment operator.

In a closely related late-breaking change: If your class has an explicit destructor, and implicit copy members, the implicit generation of those members is now deprecated (the committee would like to remove the implicit generation of copy when there is an explicit destructor, but can't because of backwards compatibility).

So in summary, any time you have a destructor declared, you should probably be thinking about explicitly declaring both copy and move members.

answered Jan 23, 2011 at 19:34

Howard Hinnant

225k55 gold badges493 silver badges624 bronze badges

2 Comments

Johann Gerell Over a year ago

This is great news. Thanks, Howard.

mmocny Over a year ago

I wrote an article on this topic, with diagrams of the new relationships: mmocny.wordpress.com/2010/12/09/implicit-move-wont-go

Grizzly · Accepted Answer · 2011-01-18 12:54:42Z

As a rule of thumb I would say add a move constructor whenever you have member variables which hold (conditionally) dynamically allocated memory. In that case its often cheaper if you can just use the existing memory and give the move source the minimal allocation it needs so it can still function (meaning be destroyed). The amount of member variables doesn't matter that much, because for types not involving dynamic memory its unlikely to make a difference whether you copy or move them (even the move constructor will have to copy them from one memory location to another somehow).

Therefore move semantices make sense, when

dynamic memory allocation is involved
move makes sense for one or more member variables (which means those involve dynamic allocation somewhere along the line).

Puppy · Accepted Answer · 2011-01-18 12:58:13Z

5

Typically, moving makes sense when the class holds some kind of resource, where a copy would involve copying that resource and moving would not. The easiest example is dynamically allocated memory. However, it is worth noting that the compiler will automatically generate move constructors and operators, just like it will for copying.

answered Jan 18, 2011 at 12:58

Puppy

147k40 gold badges271 silver badges481 bronze badges

2 Comments

Johann Gerell Over a year ago

The VS 2010 compiler will not automatically generate move constructors and operators (mentioned by Stephan in his Channel 9 series, I think in episode 9 of 10).

Puppy Over a year ago

Doesn't mention his compiler. GCC also supports rvalue references.

Martin Ba · Accepted Answer · 2011-01-18 12:50:08Z

2

Irrespective of anything that might be automatically done by the compiler I'd say that:

If any member has meaningful and beneficial move semantics, that the class should have this move semantics too. (-> std::vector members)
If any dynamic allocations are involved when copying, move operations make sense.

Put otherwise, if move can do something more efficiently than copy, it makes sense to add it. In your really_trivial a move could only be as efficient as the copy already is.

answered Jan 18, 2011 at 12:50

Martin Ba

39.4k35 gold badges204 silver badges376 bronze badges

Collectives™ on Stack Overflow

When will adding a move constructor and a move assignment operator really start make a difference?

5 Answers 5

Comments

2 Comments

Comments

2 Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

5 Answers 5

Comments

2 Comments

Comments

2 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related