rvalue-reference

In C++11, value parameters (and other values) enjoy implicit move when returned: A func(A a) { return a; // uses A::A(A&&) if it exists } At least in MSVC 2010, rvalue reference parameters need std::move : A func(A && a) { return a; // uses A::A(A const&) even if A::A(A&&) exists } I would imagine that inside functions, an rvalue reference and a value behave similar, with the only difference that in case of values, the function itself is responsible for destruction, while for rvalue references, the responsibility is outside. What is the motivation for treating them differently in the standard?

I have a simple class: class X { std::string S; X (const std::string& s) : S(s) { } }; I've read a bit about rvalues lately, and I've been wondering, if I should write constructor for X using rvalue, so I would be able do detect temporary objects of std::string type? I think it should look something like: X (std::string&& s) : S(s) { } As to my knowledge, implementation of std::string in compilers supporting C++11 should use it's move constructor when available. X (std::string&& s) : S(s) { } That is not a constructor taking an rvalue , but a constructor taking an rvalue-reference . You should

I'm having trouble overloading a function to take a value either by const reference or, if it is an rvalue, an rvalue reference. The problem is that my non-const lvalues are binding to the rvalue version of the function. I'm doing this in VC2010. #include <iostream> #include <vector> using namespace std; template <class T> void foo(const T& t) {cout << "void foo(const T&)" << endl;} template <class T> void foo(T&& t) {cout << "void foo(T&&)" << endl;} int main() { vector<int> x; foo(x); // void foo(T&&) ????? foo(vector<int>()); // void foo(T&&) } The priority seems to be to deduce foo(x) as

So after looking up move semantics I see that general consensus is to pass by value when you intend to transfer ownership. But in Scott Meyer's talk on Universal references I've noticed that std::vector::push_back has 2 overloads: void push_back( const T& value ); void push_back( T&& value ); So I thought to myself, wouldn't void push_back( T value ); be enough? I've asked a few people which ultimately lead to the following test case: #include <memory> #include <iostream> #include <type_traits> struct A { A() { std::cout << "A Default constructor\n"; } A(const A &) { std::cout << "A Copy\n"; }

I am adding new operator overloads to take advantage of c++0x rvalue references, and I feel like I'm producing a lot of redundant code. I have a class, tree , that holds a tree of algebraic operations on double values. Here is an example use case: tree x = 1.23; tree y = 8.19; tree z = (x + y)/67.31 - 3.15*y; ... std::cout << z; // prints "(1.23 + 8.19)/67.31 - 3.15*8.19" For each binary operation (like plus), each side can be either an lvalue tree , rvalue tree , or double . This results in 8 overloads for each binary operation: // core rvalue overloads for plus: tree operator +(const tree& a

Is it possible to design and how should I make overloaded operator+ for my class C to have this possible: C&& c = c1 + c2; but this not possible: c1 + c2 = something; Edit: I changed objects to small letters. c1 , c2 and c are objects of class C . && is not the logical operator&& , but rather an rvalue reference. For example writing: double&& d = 1.0 + 2.0; is 100% proper (new) C++ code, while 1.0 + 2.0 = 4.0; is obviously a compiler error. I want exactly the same, but instead for double, for my class C . Second edit: If my operator returns C or C&, I can have assignment to rvalue reference,