rvalue-reference

Is it a bug in Visual C++ 2010 or right behaviour? template<class T> T f(T const &r) { return r; } template<class T> T f(T &&r) { static_assert(false, "no way"); //< line # 10 return r; } int main() { int y = 4; f(y); //< line # 17 } I thought, the function f(T &&) should never be called but it's called with T = int &. The output: main.cpp(10): error C2338: no way main.cpp(17) : see reference to function template instantiation 'T f(T)' being compiled with [ T=int & ] Update 1 Do you know any C++x0 compiler as a reference? I've tried comeau online test-drive but could not compile r-value

Are objects inside rvalue referenced object, also rvalue referenced? struct A{ }; struct B{ A a2; }; //template<class B> void test(B &&b){ // 1. Is this the correct way? auto &&in3 = std::forward<B>(b).a2; std::cout << std::is_rvalue_reference<decltype(in3)>::value; // return true // 2. or this? auto &&in4 = b.a2; std::cout << std::is_rvalue_reference<decltype(in4)>::value; // return false } test(B()); http://coliru.stacked-crooked.com/a/bcf0f7dc4cc0440e Yes, members of rvalues are themselves rvalues. This was clarified by DR 421 But that is irrelevant here: auto &&in4 = b.a2; b is not an

The function std::move() is defined as template<typename T> typename std::remove_reference<T>::type&& move(T && t) { return static_cast<typename std::remove_reference<T>::type&&>( t ); } There are four places where I can imagine the move constructor to be called: When the parameter is passed. When the cast is performed. When the result is returned. Not in the std::move() function itself but possibly at the place where the returned reference ultimately arrives. I would bet for number 4, but I'm not 100% sure, so please explain your answer. There is no move construction going on. std::move()

Let's say I have a (trivial) class, which is move-constructible and move-assignable but not copy-constructable or copy-assignable: class movable { public: explicit movable(int) {} movable(movable&&) {} movable& operator=(movable&&) { return *this; } movable(const movable&) = delete; movable& operator=(const movable&) = delete; }; This works fine: movable m1(movable(17)); This, of course, does not work, because m1 is not an rvalue: movable m2(m1); But, I can wrap m1 in std::move , which casts it to an rvalue-reference, to make it work: movable m2(std::move(m1)); So far, so good. Now, let's say

The following definition of a min function template <typename T, typename U> constexpr auto min(T&& t, U&& u) -> decltype(t < u ? t : u) { return t < u ? t : u; } has a problem: it seems that it's perfectly legal to write min(10, 20) = 0; This has been tested with Clang 3.5 and g++ 4.9. The solution is straightforward, just use std::forward to restore the "rvalue-ness" of the arguments, i.e. modify the body and the decltype to say t < u ? std::forward<T>(t) : std::forward<U>(u) However, I'm at a loss to explain why the first definition doesn't generate an error. Given my understanding of

From what I understand the reason why it is dangerous to return rvalues references to from functions is due to the following code: T&& f(T&& x) { do_something_to_T(x); return static_cast<T&&>(x); } T f(const T& x) { T x2 = x; do_something_to_T(x2); return x2; } T&& y = f(T()); This leaves y as an undefined dangling reference. However, I don't understand why the above code even compiles? Is there ever a legitimate reason to assign a rvalue reference to another rvalue reference? Aren't rvalues suppose to be, roughly speaking, "temporaries", i.e. going to be made invalid at the end of the