Everything You Ever Wanted To Know About Move Semantics

Transcription

1 Everything You Ever Wanted To Know About Move Semantics (and then some) Howard Hinnant Ripple Jul 25, 2016

2 Outline The genesis of move semantics Special member functions Introduction to the special move members Best practices for the move members Details, details

3 How Did Move Semantics Get Started? It was all about optimizing std::vector<t>. And everything else just rode along on its coattails.

4 What is std::vector? Anatomy of a vector (simplified) vector begin() end() capacity() vector s data

5 How does a vector? vector vector vector s data vector s data

6 How does a vector move? vector vector nullptr nullptr nullptr vector s data

7 How Did Move Semantics Get Started? Remember these fundamentals about move semantics and vector, and you will have a basic understanding of all of move semantics. The rest is just details

8 Outline The genesis of move semantics Special member functions Introduction to the special move members Best practices for the move members Details, details

9 Special Members What are they?

10 Special Members Special members are those member functions that the compiler can be asked to automatically generate code for.

11 Special Members How many special members are there? 6

12 Special Members They are: default destructor assignment move move assignment X(); ~X(); X(X const&); X& operator=(x const&); X(X&&); X& operator=(x&&);

13 Special Members The special members can be: implicitly user or or or deleted user-defined

14 Special Members What counts as user-? struct X { X() {} // user- X(); // user- X() = default; // user- X() = delete; // user- };

15 Special Members What is the difference between - and deleted? Consider: struct X { template <class...args> X(Args&&...args); // The default }; // is

16 Special Members struct X { template <class...args> X(Args&&...args); // The default }; // is X can be default constructed by using the variadic.

17 Special Members struct X { template <class...args> X(Args&&...args); X() = default; }; Now X() binds to the default instead of the variadic.

18 Special Members struct X { template <class...args> X(Args&&...args); }; X() = delete; Now X() binds to the deleted default instead of the variadic. X is no longer default constructible.

19 Special Members struct X { template <class...args> X(Args&&...args); }; X() = delete; Deleted members participate in overload resolution. Members - do participate in overload resolution.

20 Special Members Under what circumstances are special members implicitly provided?

21 Special Members compiler implicitly declares default destructor assignment move move assignment Nothing user declares If the user declares no special members or s, all 6 special members will be. This part is no different from C++98/03

22 Special Members compiler implicitly declares default destructor assignment move move assignment Nothing user declares Any If the user declares any, this will inhibit the implicit declaration of the default.

23 Special Members compiler implicitly declares default destructor assignment move move assignment Nothing user declares Any default user A user- default will inhibit any other special member.

24 Special Members compiler implicitly declares default destructor assignment move move assignment Nothing user declares Any default destructor user user A user- destructor will inhibit the implicit declaration of the move members. The implicitly members are deprecated. If you declare a destructor, declare your members too, even though necessary.

25 Special Members compiler implicitly declares default destructor assignment move move assignment Nothing Any user declares default destructor user user user A user- will inhibit the default and move members.

26 Special Members compiler implicitly declares default destructor assignment move move assignment Nothing user declares Any default destructor assignment user user user user A user- assignment will inhibit the move members.

27 Special Members compiler implicitly declares default destructor assignment move move assignment Nothing user declares Any default destructor assignment move user user user user deleted deleted user A user- move member will implicitly delete the members.

28 Special Members compiler implicitly declares default destructor assignment move move assignment Nothing user declares Any default destructor assignment move move assignment user user user user deleted deleted deleted deleted user user

29 Special Members compiler implicitly declares default destructor assignment Nothing user declares Any default destructor user user user This is C++98/03 assignment user

30 Special Members compiler implicitly declares default destructor assignment move move assignment Nothing user declares Any default destructor assignment move move assignment user user user user deleted deleted deleted deleted user user

31 Outline The genesis of move semantics Special member functions Introduction to the special move members Best practices for the move members Details, details

32 What does a move do? class X : public Base { Member m_; X(X&& x) : Base(static_cast<Base&&>(x)), m_(static_cast<member&&>(x.m_)) {} };

33 What does a typical userdefined move do? class X : public Base { Member m_; X(X&& x) : Base(std::move(x)), m_(std::move(x.m_)) { x.set_to_resourceless_state(); }

34 What does a move assignment do? class X : public Base { Member m_; X& operator=(x&& x) { Base::operator= (static_cast<base&&>(x)); m_ = static_cast<member&&>(x.m_); return *this; }

35 What does a typical userdefined move assignment do? class X : public Base { Member m_; X& operator=(x&& x) { Base::operator=(std::move(x)); m_ = std::move(x.m_); x.set_to_resourceless_state(); return *this; }

36 Outline The genesis of move semantics Special member functions Introduction to the special move members Best practices for the move members Details, details

37 Can I define one special member in terms of aher? Yes.

38 Should I define one special member in terms of aher? No!

39 Should I define one special member in terms of aher? No! Give each special member the tender loving care it deserves. The entire point of move semantics is to boost performance.

40 Should I define one special member in terms of aher? Case study: the /swap idiom class X { std::vector<int> v_; public: X& operator=(x x) { // Implements v_.swap(x.v_); // both and return *this; // move assignment } }; What s to love?

41 Should I define one special member in terms of aher? Case study: the /swap idiom class X { std::vector<int> v_; public: I ve written highly optimized versions of the and move assignment operators. X& operator=(x const& x); X& operator=(x&& x); };

42 Should I define one special member in terms of aher? /swap penalty Case study: the /swap idiom lhs always needs to reallocate vector lhs never needs to reallocate vector Average case (70% slower) 1.8 Worst case 1.7 (almost 8 times slower) Best case 1.4 (same speed) % 25% 50% 75% 100% How often is lhs capacity sufficient? Speed of optimized assignment operator vs / swap assignment

43 Should I define one special member in terms of aher? Case study: the /swap idiom How hard is it to make separate optimized and move assignment operators for this case?

44 Should I define one special member in terms of aher? Case study: the /swap idiom class X { std::vector<int> v_; public: // Just keep your grubby fingers // off of the keyboard. // The defaults are optimal! }; What s to love?

45 Should I define one special member in terms of aher? Case study: the /swap idiom But the /swap idiom gives me strong exception safety! Good point. Are all of your clients willing to pay a giant performance penalty for strong exception safety on assignment?

46 Should I define one special member in terms of aher? Case study: the /swap idiom Perhaps you could interest the portion of your clients that do need strong exception safety in this generic function: template <class C> C& strong_assign(c& dest, C src) { using std::swap; swap(dest, src); return dest; }

47 Should I define one special member in terms of aher? Case study: the /swap idiom Now clients who need speed can: x = y; And clients who need strong exception safety can: strong_assign(x, y);

48 In A Hurry? If you don t have time to carefully consider all 6 special members, then just delete the members: class X { public: X(X const&) = delete; X& operator=(x const&) = delete; };

49 Outline The genesis of move semantics Special member functions Introduction to the special move members Best practices for the move members Details, details

50 What can I do with a movedfrom object? The following is a myth: All you can do with a moved-from object is destruct it or assign it a new value. That might be true for a type which has such documented preconditions.

51 What is the state of a movedfrom object? The state of a moved-from object is generally unspecified.

52 What can I do with a movedfrom object? You can do anything with a moved-from object that does require a precondition.

53 What is a precondition? A requirement in the function specification which restricts the state of the object prior to the call. For example: vector<t>::pop_back(); Requires: empty() shall be false. Precondition!

54 What can I do with a movedfrom object? Anything that does require a precondition. For example, vector<t>: destruct it. assign it a new value. get its size(). clear() it. Do pop_back() it! No precondition No precondition No precondition No precondition Precondition!

55 Guideline: Never delete the move members Deleted move members are at best redundant, and at worst, a bug

56 Guideline: Never delete the move members class X { public: X(X const&) = default; X& operator=(x const&) = default; X(X&&) = delete; X& operator=(x&&) = delete; }; Incorrect way to make a able type with no move members:

57 Guideline: Never delete the move members class X { public: X x = get_x(); // error! X(X const&) = default; X& operator=(x const&) = default; X(X&&) = delete; X& operator=(x&&) = delete; }; This type can be copied from an rvalue. Is that intended?!

58 Guideline: Never delete the move members class X { public: X(X const&) = default; X& operator=(x const&) = default; }; Correct way to make a able type with no move members:

59 Guideline: Never delete the move members class X { public: X(X const&) = delete; X& operator=(x const&) = delete; X(X&&) = delete; X& operator=(x&&) = delete; }; Correct but unadvised way to make class non-able and non-movable.

60 Guideline: Never delete the move members class X { public: X(X const&) = delete; X& operator=(x const&) = delete; X(X&&) = delete; X& operator=(x&&) = delete; }; Deleted move members are redundant.

61 Guideline: Never delete the move members class X { public: X(X const&) = delete; X& operator=(x const&) = delete; }; Better way to make class non-able and non-movable.

62 Summary Know when the compiler is defaulting or deleting special members for you, and what members will do. Always define or delete a special member when the compiler s implicit action is correct. Give tender loving care to each of the 6 special members, even if the result is to let the compiler handle it.