Read it along with, §4. The rules were reportedly designed. Deciding whether a function must take an argument by value, lvalue reference or rvalue reference depends very much on what it does. static_cast<typename remove_reference<T>::type&&> (t) The result of the function call is an rvalue (specifically, an xvalue ), so it can be bound to an rvalue reference where the function argument couldn't. It's also echoed in 5. 3. To convert an lvalue to an rvalue, you can also use the std::move() function. Arrays are lvalues. 1. Category 4 used to be a bit different in C++11, but I believe this wording is correct for C++14. , [expr. Otherwise, the type of the prvalue is T. Share. it is a reference only to rvalues. e. A glvalue of a non-function, non-array type T can be converted to a prvalue. With argument deduction, parameter of make_tuple is deduced to be: int&, and in this case i can be bound. Introduction. But the third one steals the goalKeeper object of t. 3/5 of the C++11 Standard: A reference to type “cv1 T1” is initialized by an expression of type “cv2 T2” as follows: — If the reference is an lvalue reference and the initializer expression — is an lvalue (but is not a bit-field), and “cv1 T1” is reference-compatible with “cv2 T2,” orAn expression has a possibly cv-qualified non-reference type, and has value category: lvalue, xvalue, or prvalue. 14159, are rvalues. It cannot convert from an rvalue to an lvalue reference, even a const one. 1 is rvalue, it doesn't point anywhere, and it's contained within lvalue x. An lvalue may get converted to an rvalue: that's something perfectly legit and it happens quite often. 2. We are allowed to do that because the object is an rvalue, when the constructor finishes its job, t will be destructed. At the same time, we cannot move away from const values. As an example, the operand of unary & must be a function designator, the result of [], the result of unary *, or an lvalue (C 2018 6. An lvalue (locator value) represents an object that occupies some identifiable location in memory (i. 27 Non-Modifiable Lvalueslvalue_cast(const T& rvalue) {return const_cast<T&>(rvalue);} converts a rvalue to a lvalue, by changing const reference to a non-const reference (removing const qualification on the variable). 2), then: the value contained in the referenced. Informally, "lvalue-to-rvalue conversion" means "reading the value". So. b is just an alternative name to the memory assigned to the variable a. @YueZhou Function lvalues may be bound to rvalue references. Note that the lvalue-to-rvalue conversion is not the only conversion that converts an lvalue to a prvalue: There's also the array-to-pointer conversion and the function-to-pointer conversion. (Lvalue-to-rvalue conversions on class types are rare, but do occur in some places in the language, e. If you really want to or need to specify the parameters, you can use std::move to convert an lvalue to an rvalue at the calling site. C++0x rvalue reference template argument deduction. Let's think of the addition +. I recently filed a bug against MSVC which relates to this, where the non-standard behavior caused standard-compliant code to fail to compile and/or compile with a deviant behavior. In the previous lesson ( 12. 3. If the type is a placeholder for a deduced class type, it is replaced by the return type of the function. So: since foo () returns a reference ( int& ), that makes it an lvalue itself. C++11 introduced the Rvalue reference for the first time, which is a tool that allows us to get permanent access to temporary objects in memory. If you had. Hence we know that in int t = e; , the result of the conversion sequence is a prvalue, because int is a non-reference type. r can be bound to the conversion result of e or a base class of e if the following conditions are satisfied. Taking it by rvalue reference would cause a headache to a user who has an existing lvalue or const reference to a function; they would need to std::move it (in. " So an rvalue is any expression that is not an lvalue. The output is: Copy constructor with lvalue reference. Radius: 2 2 4. 1. Conversion of a function pointer to void * shall not alter the representation. 3. Temporary materialization thus occurs in both of the OP's examples: The first temporary (with value 10) will be. This is because, in C programming, characters are internally stored as integer values known as ASCII Values. 区分左值和右值是很重要的，这是使用C++11 move语义的基础。. In example 4, a is an lvalue, becuase it has a name and I can take its address so it's ok to bind a lvalue reference b to an lvalue (int&& a) that happens to be a rvalue reference. In the second case that I've reported, in whch aString is A constructor is an LValue reference, the std::move operator will still convert it to an RValue reference and I should still. return 17;} int m=func2(); // C++03-style copying. Rvalue reference parameters and. 1/4 "Primary expressions"). One can calculate it from the equation for C-value in Equation 1 above: Equation 3: R-value = thickness / K-value. I played a bit around with composite-patterns and inheritance in c++. (If you insist to know, the result of subscripting into an rvalue array used to be an lvalue in C++11, but is an xvalue in C++14 - issue 1213 . 1: (5. In return w, the implicitly movable entity w is treated as an rvalue when the return type of the function is RRefTaker as in example three, but it is treated as an lvalue when the return type of the function is Widget && as in example four. The usual arithmetic conversions required by many arithmetic operators do invoke an lvalue-to-rvalue conversion indirectly via the standard conversion used. Hence, values bound to an rvalue reference can be moved from (not necessarily always going to be moved from, but it is allowed), and lvalues can be bound to lvalue references and can't be moved from. Explicitly call a single-argument constructor or a conversion operator. ASCII defines a set of characters for encoding text in computers. C++20 the conversion restriction regarding designated initializer lists was applied even if the parameter is a reference not restricted in this case P2468R2:Postfix operator++ requires the value-category of the operand to be an l-value, regardless of the type of the operand. Select the Configuration Properties > C/C++ > Language property page. Abbreviations of constructors, operators and destructors: Dc — Default constructorA{} is always an rvalue per [expr. U is a class type. L-value: “l-value” refers to memory location which identifies. However, a (prvalue) rvalue cannot be converted implicitly to an lvalue or xvalue, except by user-defined conversions. The compiler will synthesize a move constructor only for such class that doesn't define any of its own copy-control members (copy-constructor, copy-assignment, or destructor), and if all the non- static members. To convert an rvalue to an lvalue, you can use this lvalue helper function: template<class T> T& lvalue_ref (T&& x) { return x; } And then the call becomes: scan (lvalue_ref (std::ifstream ("myfile")), lvalue_ref (Handler ())); This is safe as the temporaries (the ifstream and Handler) aren't destructed until the end of. This article also mentioned that issue. As regards the concept, notice that there's no argument-parameter pair on the value level. Conversely, d = static_cast<float> (j)/v; produces an. "Hello, World" is not of type const char*. cv]/4. Confusion between rvalue references and const lvalue references as parameter. What I found by using this "real world" example is that if want to use the same code for lvalue ref and rvalue ref is because probably you can convert one to the other! std::ostringstream& operator<<(std::ostringstream&& oss, A const& a){ return operator<<(oss, a); } 1 Answer. Update: The code is ill-formed in C++11. That is expected. 12. I couldn't find an example of l2r applicable to class types myself; in all the seemingly applicable examples there's usually a function involved that takes lvalue-ref (like copy-ctor), for which l2r seems to be suppressed (see. If an lvalue or xvalue is used in a situation in which the compiler expects a (prvalue) rvalue, the compiler converts the lvalue or xvalue to a (prvalue) rvalue. There are operators that yield lvalues: for example, if E is an expression of pointer type, then *E is an lvalue expression referring to the object to which E points. h and move. Visual Studio warning disappears if one removes std::move. This is its value category. And an rvalue reference is a reference that binds to an rvalue. Converts between types using a combination of explicit and implicit conversions. Say we want to steal from an lvalue: int main() { Holder h1(1000); // h1 is an lvalue Holder h2(h1); // copy-constructor invoked (because of lvalue in input) } This will not work: since h2 receives an lvalue in input, the copy constructor is being triggered. For the class type A, f (a); causes the copy constructor of A to be invoked. The standard defines (§3. If you really want to pass i to g (), you have two options: provide a temporary object which is a copy of i (then considered as a rvalue) g (int {i}) force the conversion to rvalue reference with std::move (); then the original i must not. Both of g and h are legal and the reference binds directly. thus, this is legal: string&& s = foo (); // extends lifetime as before s += "bar"; baz (std::move (s)); // move the temporary into the baz function. Now enter C++11 with rvalue references and move semantics. Example: int a. const A& x = 1; //compile x = 2; //error! A&& xxx = 1; //compile A& xx = 1; //does not compile. I still can't figure out which one is correct though :(–In your specific case, since you are calling the function immediately you don't need to worry about taking ownership of it, so it would be better to take the function by const reference. We provide you with easy how-to’s and step-by-step instructions that provide understanding and guidance for a successful installation process, ensuring professional results. Expressions Each expression in C (an operator with its arguments, a function call, a constant, a variable name, etc) is characterized by two independent. lvalue references are marked with one ampersand (&). As shown in the code below, by using move()funciton, when I bound a converted lvalue to an rvalue reference, and then changed the value of the rvalue. If an lvalue or xvalue is used in a situation in which the compiler expects a (prvalue) rvalue, the compiler converts the lvalue or xvalue to a (prvalue) rvalue. thus, this is legal: string&& s = foo (); // extends lifetime as before s += "bar"; baz (std::move (s)); // move the temporary into the baz function. Our motivation for this is generally to use it as the source of a move operation, and that’s why the way to convert an lvalue to an rvalue is to use std::move. When you have a named value, as in . A simpler case: template <typename T> void foo(T&& ) { } foo(1); // T is int int x; foo(x); // T is int& When you specify float for x, you are specifying that that particular argument will have type float&&, and you cannot implicitly convert an lvalue float to an rvalue. The output is: Copy constructor with lvalue reference. ”. Address of an lvalue may be taken: &++i and &std::endl are valid expressions. 7. (This is as per my understanding, please correct it otherwise). h, the output is same as Clang output it's reasonable. 3 -- Lvalue references ), we discussed how an lvalue reference can only bind to a modifiable lvalue. [2] Then, the resulting value is placed in a temporary variable of type T. It is used to convert an lvalue into an rvalue. Thus, if the thickness is 1 inch, and the K-value is 0. A so called 'rvalue-reference' can bind to a temporary , but anything with a name is an lvalue, so you need to forward<> () it if you need it's rvalueness back. An lvalue is a value bound to a definitive region of memory whereas an rvalue is an expression value whose existence is temporary and who does not necessarily refer to a definitive region of memory. This type of static_cast is used to implement move semantics in std::move. This approach is hard to generalize to more input arguments. Found workaround how to use rvalue as lvalue. (since C++11)20. The && syntax is either referring to a rvalue-reference or a universal-reference. c++11 decltype returns reference type. So a and b are converted to rvalues before getting summed. 45. C++ pass parameter by rvalue reference if possible, otherwise copy the lvalue reference. For non-class types you cannot assign to rvalues. OK. 10): An lvalue (so called, historically, because lvalues could appear on the left-hand side of an assignment expression) designates a function or an object. You would need const_cast<char*&> (a) in order to have an lvalue to assign to, and that brings up the next problem. Here is a silly code that doesn't compile: int x; 1 = x; // error: expression. If element at this position doesn't exist, function. This is what std::move is for. double && does not work for lvalues. Set the Enforce type conversion rules property to /Zc:rvalueCast or. "3" is an integer, and an rvalue. That stops the move if it is an lvalue reference. 2 days ago · C++ Operator Overloading [ ] for lvalue and rvalue. You can convert an lvalue to an rvalue by casting it to an xvalue; this is conveniently encapsulated into the type-deducing cast. Whether it’s heap or stack, and it’s addressable. Lvalue to rvalue conversion changes the value category of an expression, without changing its type. 9. Hence, the end result is the attempted binding of the rvalue. You must explicitly use std::move (or a cast) to convert an lvalue into an rvalue reference, and an rvalue reference will never bind to an lvalue on its own. Refer to the Essential C++ blog for RAII. Here’s a much more concise rundown (assuming you know basic C++ already): Every C++ expression is either an lvalue or rvalue. 5. All you have to do here is make sure you get a pointer to an array, rather than a pointer to the first element of the array. Being an lvalue or an rvalue is a property of an expression; that is, every expression is either an lvalue or an rvalue. 5. It is really about rvalues vs. In the previous question, I asked how this code should work: void f (const std::string &); //less efficient void f (std::string &&); //more efficient void g (const char * arg) { f (arg); } It seems that the move overload should probably be called because of the. B. I checked the C++ standard, and it clearly states that (clause 3. As well as the potentially dangling lvalue references you've identified, this led in C++03 to the situation where operator<< on a temporary ostream could be called with a char (member function operator) but not with a string (free operator); C++11 fixes this with free operator overloads for rvalue references and rvalue *this overload for member. In int *p = &x;: x is an lvalue, referring to the variable of that name, &x is an rvalue, it's part of the initializer (specifically, an assignment-expression ), p is neither an rvalue nor an. You should provide an overload taking rvalue references when you want to move the passed argument. } or in . 2. C. You can define const vector<int> a{2, 1, 3}, b{3, 1, 2}; then a, b are lvalues and thus const reference will be an exactThe possibly constrained (since C++20) auto specifier can be used as array element type in the declaration of a pointer or reference to array, which deduces the element type from the initializer or the function argument (since C++14), e. You need to pass in an rvalue, and for that you need to use std::move: Insert(std::move(key), Value()); // No compiler error any more I can see why this is. The type of the variable k is an r-value reference, but that's fine. You can't assign to an object that is const. 12. has an address). When such a binding occurs to a prvalue, a temporary object is materialized. c++11标准基本上是通过举例来说明一个表达式是否是一个lvalue还是rvalue的。. There are operators that yield lvalues: for example, if E is an expression of pointer type, then *E is an lvalue expression referring to the object to which E points. int array [10]; int * p = array; // [1] The expression array in [1] is an lvalue of type int (&) [10] that gets converted to an rvalue of type int *p, that is, the rvalue array of N==10 T. In such cases: [1] First, implicit type conversion to T is applied if necessary. The example is interesting because it seems that only lvalues are combined. 3. 右值（rvalue）：. That would also solve the <T> issue BTW. Assignment involving scalar types requires a modifiable lvalue on the left hand side of the assignment operator. For example in the following instructions. ). Recall that there is a difference between the concept of an Lvalue and an Rvalue. This is a helper function to allow perfect forwarding of arguments taken as rvalue references to deduced types, preserving any potential move semantics involved. func () indeed returns a prvalue and from the C++ Standard par. The term “identity” is used by the C++ standard, but is not well-defined. Unlike a reference to non-const (which can only bind to modifiable lvalues), a reference to const can bind to modifiable lvalues, non-modifiable lvalues, and rvalues. Example: std::unique_ptr<int> get_int() { auto p = std::make_unique<int>(1); // `p` is an lvalue but treated as an rvalue in the return statement. std::function has a non-explicit constructor that accepts lambda closures, so there is implicit conversion. Basically, VS will allocate the space somewhere and just let the reference point to it, as if it was a reference-to- const without the constness (or in C++11 an rvalue reference). 6 — Pass by const lvalue reference. The result of std::move is an xvalue [1], which is a type of glvalue; and converting a glvalue to an lvalue reference with reinterpret_cast appears to be allowed by the wording. rvalue — The expression that refers to a. Once a move constructor is called upon the reference, the original object should be reset to the origin state, and so does any reference to it. g. Both rvalues and lvalues can be modified. std::apply perfect-forwards the tuple to std::get to access elements of the tuple. Then std::forward<SomeClass&> (element) will be invoked, and the instantiation of std::forward would be. The actual problem is instantiating Parent with a reference type to begin with; in C++11 this is generally avoided via application of std::decay. The type after conversion is not qualified by either const or volatile. An lvalue is an expression that yields an object reference, such as a variable name, an array. Note that this must wait until construction is complete for two reasons. key here is Key&& key - this is an lvalue! It has a name, and you can take its address. 2), an xvalue if T is an rvalue reference to object type, and a prvalue otherwise. The expression *this is an lvalue; A {} is an rvalue (prvalue) even though they designate the same temporary object. There is no lvalue-to-rvalue conversion in this scenario. e. It's not an rvalue reference, but a forwarding reference; which could preserve the value category of the argument. 6. The pass-by-value version allows an lvalue argument and makes a copy of it. rvalues can bind to rvalue references and const lvalue references, e. Nothing is changed except the value category. Abbreviations in this article. And an rvalue reference is a reference that binds to an rvalue. The entire point is that you know that this entity references an rvalue and you can legitimately move its content. 1) If the reference is an lvalue reference. It shouldn't be something special so i coded that a component has a parent as composite, the composite should derrived from component and use the constructor from it's base class (Component). From the linked documentation. Compiled with "g++ -std=c++0x". An obvious example of an lvalue expression is an identifier with suitable type and storage class. – Corristo. using g++. So you can write a couple of convert functions . Under the conditions specified in [dcl. And there is no mandated lvalue-to-rvalue conversion. specifically, the argument expression is an rvalue that is bound to the rvalue reference parameter. Among. I don't really understand why an rvalue and a non-modifiable lvalue would be the same. , buggy). This example might clarify it: 16. C++11 also invented the forwarding reference: that when there’s a deduced type T directly modified by &&, T can sometimes be deduced as an lvalue reference type. This is. Of course, this is not surprising: no one would expect. For the second overload, it would call operator const P&() const&. std::move doesn't move anything, it just converts the type of the expression to an rvalue reference. This would seem to be possible since there is a std::vector::push_back(value_type&& val) function. As long as no const is involved, the expression T() is a modifiable rvalue, to be more precise. const A& x = 1; //compile x = 2; //error! A&& xxx = 1; //compile A& xx = 1; //does not compile. lval), array-to-pointer (conv. They are declared using the ‘&’ before the name of the variable. If you wanted to move an lvalue, you would likely have to use an RAII container that does this for you. (An xvalue is an rvalue). Variables of type rvalue reference have to be initialized in their definition like variables of type lvalue reference. C++03, section §3. A move constructor and move assignment operator can now. This function takes an lvalue reference and converts it to an rvalue reference. template <typename T> StreamWriter& StreamWriter::operator<< (const T& source) { Write (&source); return *this; } Share. Rvalue references work in principle similarly to Lvalue references: We declare them by writing the data type of the rvalue followed by && and an identifier. 1/2 (your. 1) does not accept such code (makes perfect sense). C++ does not allow you to get an r-value reference to a variable without an explicit conversion. It is illegal in C++ to attach non-const references to rvalues. This way you explicitly say T&& should not match an lvalue-reference. So. But due to the the existence of std::vector::push_back(value_type const & val), which copies and would be the overriding call, I need to convert the lvalue object to an rvalue. , [expr. Values return by functions/methods and expression are temporary values, so you do have to use std::move to move them (C++ standard to convert to rvalue) when you pass them to functions/methods. std::move is there to allow for the casting. The reason why you need to const is to make x not a forwarding reference. In the function, the argument has a name and thus is an lvalue. You are returning a copy of A from test so *c triggers the construction of a copy of c. The following diagram illustrates the relationships between the. @banana36 With that function, calling foo(std::move(my_ptr_var)) wont actually pass ownership. 1Primary categories lvalue prvalue xvalue 2Mixed categories glvalue rvalue 3Special categories Pending member function call Void expressions Bit-fields Move. e. No, not really. an lvalue reference instead of an rvalue reference) and had the appropriate cv-qualification, then it's probably the programmer's mistake. Oct 31, 2016 at 20:29. 12. By make_tuple<int> you make make_tuple signature look like: make_tuple(int&&). It's actually a cast. The expression 0 is. The reference could be bound to the result of the implicit conversion if it wasn't non-const because the result of that implicit conversion is an rvalue i. Radius: 2 2 4. must error, because you're trying to pass an rvalue argument, std::move(n), to a lvalue reference parameter, T&. i by itself is an lvalue. Even if the variable's type is rvalue reference, the expression consisting of its name is an lvalue expression; vector has two overloads of assignment operator, one for Lvalue reference. If an lvalue-to-rvalue conversion were performed on s, it would also call the copy constructor; [conv. For example in an expression. e. Without lvalue-to-rvalue conversion, it cannot read it's value. 3. An lvalue (until C++11) A glvalue (since C++11) of any non-function, non-array type T can be implicitly converted to an rvalue. template <class T, class Other = T> T exchange(T& val, Other&& new_val). The expression x is an lvalue, so it is converted. It is VC++'s evil extension. An lvalue is a glvalue that isn't an xvalue. The goal of rvalue references is sparing copies and using move semantics. You can: int&& x = 3; x is now an lvalue. 1. — even if the implicit object parameter is not const-qualified, an rvalue can be bound to the parameter as long as in all other respects the argument can be converted to the type of the implicit object parameter. Thus, this syntax is now legal: T&& r = T(); rvalue references primarily provide for the following: Move semantics. So when. and includes the following bullet which the examle belongs to: the evaluation of e results in the evaluation of a member ex of the set of potential results of e, and ex names a variable x that is not odr-used by ex (3. The only references that are allowed to bind to object rvalues (including prvalues) are rvalue references and const non- volatile lvalue references. Creating a temporary object is usually not the desired behavior. type. and write_Lvalue will only accept an lvalue. Forwarding references are a special kind of references that preserve the value category of a function argument, making it. – int a = 1; // a is an lvalue int b = 2; // b is an lvalue int c = a + b; // + needs rvalues, so a and b are converted to rvalues // and an rvalue is returned. I discovered that N3290 (identical to C++11 standard) contains non-normative example of binding double&& to rvalue generated from int lvalue, and the updated wording in §8. arg the expression (it is an expression at lines 3 and 4) has type int and value category "lvalue". > In general, if I need an rvalue and it's legal to convert the lvalue I have into an rvalue, the compiler should do it automatically. Your terminology needs improvement. It makes sure a thing& x is passed as a value category lvalue, and thing&& x passed as an rvalue. If T is a non-class type, the type of the prvalue is the cv-unqualified version of T. The first are categories for the type of a variable/member. The expressions f (), f (). The only thing that can be an rvalue or an lvalue is an expression. Using it only makes sense inside of a template, where you choose whether to move or not depending on a template argument. static_cast<Type> (expression) belongs to one of the following value categories: or an rvalue reference to a function type is an lvalue. 5. Related reference: “Pointers” on page 114. Yes. If encodeData() does not change dataBuff then the simplest. I would respect the first compiler more, it is at least honest with its inefficiency. To get a lvalue expression to the value pointed to by a pointer, just use the unary * operator. For example, assume you pass an rvalue reference to an object of type X to a function template that takes type T&& as its parameter. It would capitalize std::strings, and display each parameter after they are capitalized. 5, then the R-value is 2. 0. 6. An lvalue may be used to initialize an lvalue reference; this associates a new name with the object identified by the expression. The value category of a compound literal is lvalue (its address can be taken). The C++ Standard does use the term rvalue, defining it indirectly with this sentence: "Every expression is either an lvalue or an rvalue. That is the whole point of references. The "my target must be copy-constructable" requirement of std::function is due to its own requirement of being copy-constructable. This allows you to explicitly move from an lvalue, using move to. And so on. foo now is null. (An xvalue is an rvalue). This implies that the compilers that accept the above code without a diagnostic are non-conforming (i. e. , cv1 shall be const), or the reference shall be an rvalue reference. lval]/3. Follow. However, there is no reason why converting from one reference type to another as a cast should do anything at run time. That being said, and assuming you don't want to overload doStuff (otherwise see Hinnant's answer), you can write a utility. That's right according also to the C++ Standard (talking about the lvalue-to-rvalue conversion): 4. I am trying to figure out the meaning of the following snippet: int main() { int&& a = 2; int& b = a; // (*) } I know a is an lvalue expression of type "rvalue reference to int", and b is a general variable with type "lvalue reference to int". The new version creates a temporary of type double for the conversion int -> double and binds. IBM® continues to develop and implement the features of the new standard. cond]/7. Lvalue to rvalue conversion changes the value category of an expression, without changing its type. Value categories. addv<Adder,int,int>(std::move(adder),a,b); Edit: Convert might be a bit misleading. Use const Type& when you don't need to change or copy the argument at all, use pass-by-value when you want a modifiable value but don't care how you get it, and use Type& and Type&&. "When the function parameter type is of the form T&& where T is a template parameter, and the function argument is an lvalue of type A, the type A& is used for template argument deduction. arg the variable has type int&& and no value category. As @IgorTandetnik said - anything with a name can be assumed an lvalue. move simply returns an rvalue reference to its argument, equivalent to. The typical way to accept both lvalues and rvalues is to make a function that takes a const reference. Which basically triggers the non-const rvalue to non-const lvalue conversion and makes all the difference in the example above. There is no implicit conversion as suggested in the title, the reference binds directly to the. When being passed an lvalue, the template parameter would be deduced as lvalue-reference, after reference. 1. For example, this code will not compile. Variables are lvalues, and usually variables appear on the left of an expression. It's not an rvalue reference, but a forwarding reference; which could preserve the value category of the argument. User-defined conversion function and casting to reference. Jun 27 at 7:34. The reason why you need to const is to make x not a forwarding reference. 97 * @brief Convert a value to an rvalue. 2, and 4. Here's what happens when we call move with lvalue: Object a; // a is lvalue Object b = std::move (a); and corresponding move instantiation:3. - tl:dr: Binding lvalues to rvalue-parameters is not allowed (except if the lvalue is a function), and binding rvalues to non-const lvalue-parameters is also not allowed (but const lvalue-parameters would be ok). The effect of any implicit conversion is the same as performing the corresponding declaration and initialization and then using the temporary variable as the result of the conversion. Rvalue to lvalue conversion? 2. The "l" and "r" in "lvalue reference" and "rvalue reference" refers to the categories of values to which the reference can bind, not to the category of the id-expression naming a variable of this reference type. An lvalue or xvalue is an expression that refers to such an object. The Microsoft documentation is wrong. Either have a single function taking by value and moving from it, or have two functions, one taking lvalue ref and copying and one taking rvalue ref and moving.