As skypjack correctly comments, accessing an object through its name always results in an lvalue reference. This is a safety feature and if you think it through you will realise that you are glad of it. As you know, std::move simply casts an l-value reference to an r-value reference. If we use the returned r-value … Read more
There are a few occasions when it is appropriate, but they are relatively rare. The case comes up in one example when you want to allow the client to move from a data member. For example: template <class Iter> class move_iterator { private: Iter i_; public: … value_type&& operator*() const {return std::move(*i_);} … };
And so, is the one shown by the example a well-defined behavior? Yes, the behaviour shown in the example is the only behaviour allowed by the standard. That is because std::move doesn’t move. The things that move are move constructors and move assignment operators. All std::move does is change an lvalue into an xvalue, so … Read more
First, there’s probably a misconception in the question I’ll address: Whenever you see T&& t in code (And T is an actual type, not a template type), keep in mind the value category of t is an lvalue(reference), not an rvalue(temporary) anymore. It’s very confusing. The T&& merely means that t is constructed from an … Read more
Yes. See [class.copy] p32 When the criteria for elision of a copy operation are met or would be met save for the fact that the source object is a function parameter, and the object to be copied is designated by an lvalue, overload resolution to select the constructor for the copy is first performed as … Read more
In this example, there is no difference. We will end up with 3 ints with value 100. There could definitely be a difference with different types though. For instance, let’s consider something like vector<int>: std::vector<int> a = {1, 2, 3, 4, 5}; // a has size 5 auto a_copy = a; // copy a. now … Read more
Guideline Never delete the special move members. In typical code (such as in your question), there are two motivations to delete the move members. One of those motivations produces incorrect code (as in your example), and for the other motivation the deletion of the move members is redundant (does no harm nor good). If you … Read more
Yes both are the same. But struct Example { string a, b; Example(Example&& mE) = default; Example& operator=(Example&& mE) = default; } This version will permits you to skip the body definition. However, you have to follow some rules when you declare explicitly-defaulted-functions : 8.4.2 Explicitly-defaulted functions [dcl.fct.def.default] A function definition of the form: attribute-speciļ¬er-seqopt … Read more
The two are very different and complementary tools. std::move deduces the argument and unconditionally creates an rvalue expression. This makes sense to apply to an actual object or variable. std::forward takes a mandatory template argument (you must specify this!) and magically creates an lvalue or an rvalue expression depending on what the type was (by … Read more
Maybe this clause from 8.5.4.5 explains it (my emphasis): An object of type std::initializer_list is constructed from an initializer list as if the implementation allocated an array of N elements of type E, where N is the number of elements in the initializer list. Each element of that array is copy-initialized with the corresponding element … Read more