rValue use - c++ 11

Question

I am learning c++ via the book from his creator, I understood that rValue is basically what can't be defined via it's address & you want to move it instead of copy.

Later in this book Stroustrup give an example of a Points struct

struct Point{
  int x,y;
}

struct Points{
  vector<Point> elem;
  Points(Point p0){elem.push_back(p0)};
  ...
}

Point x2{ {100,200} }

So my question is basically why in the constructor it does not use an rValue to move the sent value ?

Maybe like:

struct Points{
  vector<Point> elem;
  Points(Point&& p0){elem.push_back(p0)};
  ...
}

Is it more proper / less clear to do it?

regards

Answer 1

Moving values is especially useful when moving is cheaper than copying. As it happens, copying an int is super cheap. Your CPU will do it all the time, as it loads values from memory to registers, or between registers. As a result, for an int moving is the same as copying.

Your Point is two integers, and the same logic still holds. But vector<Point> is another matter. You'll find that sizeof(Points) is a small number. That's because it does not include sizeof(Point)*elem.size(), a quantity that can vary at runtime. And that's where moving becomes beneficial. Moving that vector moves the sizeof(Point)*elem.size().

Answer 2

What exactly do you mean by "it does not use an rValue"? Do you mean p0 is not "sent" as rvalue or do you mean the call to push_back does not use an rvalue?

1. Point&& p0 is initialized with an rvalue - so far so good.
2. push_back (p0) copies an lvalue, what you probably wanted to do was: push_back (std::move (p0)).

There is a good mnemonic you could use in order to distinguish between lvalues and rvalues:

Whenever there is a name for an object, it is an lvalue, whenever an object does not have a name, it is an rvalue.

For example: call_to_some_function (std::string {"Hi there"});, here the string passed to the function does not have a name, it is an rvalue. The same applies to all temporaries.

 void some_function (std::string&& what)
 {
       do_something_with (what); // <- what is an lvalue
       do_something_else (std::move (what)); // <- turned into rvalue
       const std::string& foo = get_some_foo_string ();
       do_something_else (std::move (foo)); // <- No rvalue here!
 }