Pass by value vs pass by rvalue reference

by

What do rvalue usages say about an interface versus copying?
rvalue suggests to the caller that the function both wants to own the value and has no intention of letting the caller know of any changes it has made. Consider the following (I know you said no lvalue references in your example, but bear with me):

//Hello. I want my own local copy of your Widget that I will manipulate,
//but I don't want my changes to affect the one you have. I may or may not
//hold onto it for later, but that's none of your business.
void foo(Widget w);

//Hello. I want to take your Widget and play with it. It may be in a
//different state than when you gave it to me, but it'll still be yours
//when I'm finished. Trust me!
void foo(Widget& w);

//Hello. Can I see that Widget of yours? I don't want to mess with it;
//I just want to check something out on it. Read that one value from it,
//or observe what state it's in. I won't touch it and I won't keep it.
void foo(const Widget& w);

//Hello. Ooh, I like that Widget you have. You're not going to use it
//anymore, are you? Please just give it to me. Thank you! It's my
//responsibility now, so don't worry about it anymore, m'kay?
void foo(Widget&& w);

For another way of looking at it:

//Here, let me buy you a new car just like mine. I don't care if you wreck
//it or give it a new paint job; you have yours and I have mine.
void foo(Car c);

//Here are the keys to my car. I understand that it may come back...
//not quite the same... as I lent it to you, but I'm okay with that.
void foo(Car& c);

//Here are the keys to my car as long as you promise to not give it a
//paint job or anything like that
void foo(const Car& c);

//I don't need my car anymore, so I'm signing the title over to you now.
//Happy birthday!
void foo(Car&& c);

Now, if Widgets have to remain unique (as actual widgets in, say, GTK do) then the first option cannot work. The second, third and fourth options make sense, because there’s still only one real representation of the data. Anyway, that’s what those semantics say to me when I see them in code.

Now, as for efficiency: it depends. rvalue references can save a lot of time if Widget has a pointer to a data member whose pointed-to contents can be rather large (think an array). Since the caller used an rvalue, they’re saying they don’t care about what they’re giving you anymore. So, if you want to move the caller’s Widget’s contents into your Widget, just take their pointer. No need to meticulously copy each element in the data structure their pointer points to. This can lead to pretty good improvements in speed (again, think arrays). But if the Widget class doesn’t have any such thing, this benefit is nowhere to be seen.

Hopefully that gets at what you were asking; if not, I can perhaps expand/clarify things.

More Related Contents:

  1. Why compiler gives the message "call of overloaded function is ambiguous" here in C++11?
  2. what is the concept of evaluation of expression z = (y = 30) + (y = 10) + (y = 20); [closed]
  3. Has C++ standard changed with respect to the use of indeterminate values and undefined behavior in C++14?
  4. Implementation C++14 make_integer_sequence
  5. Differences between std::make_unique and std::unique_ptr with new
  6. Is it a conforming compiler extension to treat non-constexpr standard library functions as constexpr?
  7. Is it safe to link C++17, C++14, and C++11 objects
  8. C++11 aggregate initialization for classes with non-static member initializers
  9. Overload resolution between object, rvalue reference, const reference
  10. Can returning a local variable by value in C++11/14 result in the return value being constructed by rvalue when no copy/move is involved?
  11. Why are lambda expressions not allowed in an unevaluated operands but allowed in the unevaluated portions of constant expressions?
  12. Try to understand compiler error message: default member initializer required before the end of its enclosing class
  13. Constant expression initializer for static class member of type double
  14. Is #pragma once part of the C++11 standard?
  15. Capturing perfectly-forwarded variable in lambda
  16. Parallel Loops in C++
  17. Lambda capture as const reference?
  18. How to extract the source filename without path and suffix at compile time?
  19. Are notes and examples in the core language specification of the C++ Standard non-normative?
  20. Is there an automatic noexcept specifier?
  21. Check traits for all variadic template arguments
  22. Which headers in the C++ standard library are guaranteed to include another header?
  23. How to immediately invoke a C++ lambda?
  24. error::make_unique is not a member of ‘std’
  25. Raw pointer lookup for sets of unique_ptrs
  26. Classes with both template and non-template conversion operators in the condition of switch statement
  27. Why does constexpr static member (of type class) require a definition?
  28. Using std::make_unique with a custom deleter
  29. What’s the standard/official name for universal references?
  30. Reference invalidation after applying reverse_iterator on a custom made iterator

Leave a Comment