Insert(key, Value()); // Compiler error here key here is Key&& key – this is an lvalue! It has a name, and you can take its address. It’s just that type of that lvalue is “rvalue reference to Key“. You need to pass in an rvalue, and for that you need to use std::move: Insert(std::move(key), Value()); … Read more
Is bar an rvalue or an lvalue? The question answers itself. Whatever has a name is an lvalue(1). So bar is an lvalue. Its type is “rvalue reference to string“, but it’s an lvalue of that type. If you want to treat it as an rvalue, you need to apply std::move() to it. If you … Read more
You can restrict T to not be an lvalue reference, and thus prevent lvalues from binding to it: #include <type_traits> struct OwnershipReceiver { template <typename T, class = typename std::enable_if < !std::is_lvalue_reference<T>::value >::type > void receive_ownership(T&& t) { // taking file descriptor of t, and clear t } }; It might also be a good … Read more
First example std::vector<int> return_vector(void) { std::vector<int> tmp {1,2,3,4,5}; return tmp; } std::vector<int> &&rval_ref = return_vector(); The first example returns a temporary which is caught by rval_ref. That temporary will have its life extended beyond the rval_ref definition and you can use it as if you had caught it by value. This is very similar to … Read more
In the case that you do know that t will not be in a moved-from state after the call to f, your two somewhat sensible options are: return std::forward<T>(t) with type T&&, which avoids any construction but allows for writing e.g. auto&& ref = wrapper(42);, which leaves ref a dangling reference return std::forward<T>(t) with type … Read more
std::is_convertible<From, To> (the type trait) checks is type From is implicitly convertible to type To. std::convertible_to<From, To> (the concept) checks that From is both implicitly and explicitly convertible to To. It’s rare that this is not the case, such types are ridiculous, but it’s nice in generic code to just not have to worry about … Read more
As you can see, ByVal produces 1 extra move compared to pair of reference overloads. So the question is: is it worth it? When would you create two overloads instead of one simple pass by value function? +1 Most people who ask this question don’t bother to do the analysis. So you get my upvote … Read more
Is bar an rvalue or an lvalue? The question answers itself. Whatever has a name is an lvalue(1). So bar is an lvalue. Its type is “rvalue reference to string“, but it’s an lvalue of that type. If you want to treat it as an rvalue, you need to apply std::move() to it. If you … Read more
You’ve missed a significant optimization in your copy assignment operator. And subsequently the situation has gotten confused. AnObject& operator = ( const AnObject& rh ) { if (this != &rh) { if (n != rh.n) { delete [] a; n = 0; a = new int [ rh.n ]; n = rh.n; } std::copy(rh.a, rh.a+n, … Read more
Expensive-to-move types are rare in modern C++ usage. If you are concerned about the cost of the move, write both overloads: void set_a(const A& a) { _a = a; } void set_a(A&& a) { _a = std::move(a); } or a perfect-forwarding setter: template <typename T> void set_a(T&& a) { _a = std::forward<T>(a); } that will … Read more