Introduction. 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. 1. Whenever an lvalue a glvalue appears in a context where an rvalue a prvalue is expected, the lvalue glvalue is converted to an rvalue a prvalue; see 4. The biggest difference between a C++03 reference (now called an lvalue reference in C++11) is that it can bind to an rvalue like a temporary without having to be const. If you wanted to move an rvalue, you’re in luck!14. In k++, the expression k is an l-value (roughly speaking, it has a name), which is its value-category. C++0x: rvalue reference versus non-const lvalue. An rvalue reference is a new type. 左值（lvalue）：指向内存位置的表达式被称为左值（lvalue）表达式。. For example second type of the pair should be std::string , not const std::string * and all your problems would go away. Correct. However, a (prvalue) rvalue cannot be converted implicitly to an lvalue or xvalue, except by user-defined conversions. To set this compiler option in the Visual Studio development environment. To mark the place(s) where you want to take advantage of the licence to ruthlessly plunder it, you have to convert it to an rvalue-reference on passing it on, for example with std::move or std::forward, the latter mostly for templates. 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. Temporary materialization thus occurs in both of the OP's examples: The first temporary (with value 10) will be. @user2308211: I think what I might have meant to say (back when I didn't know any C++!) was that vec4(). Expressions Each expression in C (an operator with its arguments, a function call, a constant, a variable name, etc) is characterized by two independent. While the type of _x is 'r-value reference to std::vector<int>', it is still an l-value as it has a name. For example second type of the pair should be std::string, not const std::string * and all your problems would go away. const foo&& can only bind to an rvalue, but const foo& can bind to both lvalues and rvalues. That is the historical origin of the letters l. An rvalue is any expression that has a value, but cannot have a value assigned to it. Whenever an lvalue appears in a context where an rvalue is expected, the lvalue is converted to an rvalue; see 4. Without this, the compiler will complain that you "cannot bind non-const lvalue reference of type 'std::string&' to an rvalue. In that case, consider processing only one argument at a time, leaving the remaining ones as rvalue-references. Since you can call the function object std::bind gives you multiple times, it cannot “use up” the captured argument so it will be passed as an lvalue reference. 2) If target-type is an rvalue reference type, static_cast converts the value of glvalue, class prvalue, or array prvalue (until C++17) any lvalue (since C++17) expression to xvalue referring to the same object as the expression, or to its base sub-object (depending on target-type). Operationally, the difference among these kinds of expressions is this:std::function can be move-constructed from rvalue of a functor object. 1, 4. Deciding whether a function must take an argument by value, lvalue reference or rvalue reference depends very much on what it does. Forwarding referece works with both lvalues and rvalues, with the help of template argument deduction. e. You can: int&& x = 3; x is now an lvalue. int f( int ); int f( int && ); int f( int const & ); int q = f( 3 ); Removing f( int ) causes both Clang and GCC to prefer the rvalue reference over the lvalue reference. 20 and lower) & R-value, higher the number the better (R-5 and higher). A glvalue of a non-function, non-array type T can be converted to a prvalue. An rvalue is constant, it cannot be changed. In C++03 copying the rvalue to an lvalue is the preferred choice (in some cases you can bind an lvalue reference to const to achieve a similar effect): int func2(){ // an rvalue expression. If T is not a class type, the type of the rvalue (until C++11) prvalue (since C++11) is the cv-unqualified version of T. 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. 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. Function to pointer An lvalue that is a function can be converted to a C++11 (prvalue) C++11 rvalue that is a pointer to a function of the same type, except when the expression is used as the operand of the &(address) operator, the () (function call) operator, or the sizeof operator. The fact that you pass bind itself an rvalue only means that there is. It can convert lvalues to lvalue references and rvalues to rvalue references. 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. The Lvalue refers to a modifiable object in c++ that can be either left or right side of the assignment operator. rvalue references allow automatic moving/copying based upon context (for example the moving of a temporary) trying to simulate this with an lvalue style copy constructor (which actually performed a move) would likely be disastrous. std::move performs a static_cast to an rvalue reference type and returns the rvalue reference. Rvalue references enable you to distinguish an lvalue from an rvalue. You can also convert any. There are two common ways to get an xvalue expression: Use std::move to move an object. If t returns by rvalue reference, you obtain a reference to whatever was returned. . 2. Using our understanding of. rvalue references are marked with two ampersands (&&). That's the pass-by-value case. 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. It can convert between pointers. 16. "Hello, World" is not of type const char*. Rvalue to lvalue conversion? 2. 左值可以出现在赋值号的左边或右边。. You would then need to add a destructor to AttrDec and delete the pointer in it and add a copy constructor. You should provide an overload taking rvalue references when you want to move the passed argument. You cannot get an rvalue of array type. There's no benefit in this case. i by itself is an lvalue. ) is characterized by two independent properties: a type and a value category. Second (and you probably missed that), const char* is converted to a rvalue std::string via the const char* non-explicit constructor of std::string (# 5 in the link). 2, and 4. Thus, if the thickness is 1 inch, and the K-value is 0. It is still not allowed per [dcl. An obvious example of an lvalue expression is an identifier with suitable type and storage class. Since int() isn't an lvalue, you can't assign to int(). Consequently, it's not legal to apply the ++ operator to the. An lvalue (locator value) represents an object that occupies some identifiable location in memory (i. e. We're talking about the temporary object created by Contrived(), it doesn't make sense to say "this object is an rvalue". Example: int a = 10; // Declaring lvalue reference int& lref = a; // Declaring rvalue reference int&& rref = 20; Explanation: The following code will print True as both the variable are pointing to the same memory location. move simply returns an rvalue reference to its argument, equivalent to. 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. So MSVC++ is giving incorrect result (in case of C++ code). Indeed it does. 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. 1: A glvalue of a non-function, non-array type T can be. has an address). A void * value resulting from such a conversion can be converted back to the original function pointer type, using an explicit cast, without loss of information. Lvalue to rvalue conversion. it can be passed to a copy constructor or copy assignment operator as well (although overload resolution will prefer passing to a function which takes a rvalue reference). C++98 assigning a value to a volatile variable might result in an unnecessary read due to the lvalue-to-rvalue conversion applied to the assignment result introduce discarded-value expressions and exclude this case from the list of cases that require the conversion CWG 1343: C++98 sequencing of destructor calls inExcept for an implicit object parameter, for which see 13. I have tried to simulate the assignment of the object (pair. In the introduction to "Effective Modern C++" it says: A useful heuristic to determine whether an expression is an lvalue is to ask if you can take its address. return 17; //an lvalue reference to an rvalue} In C++03 copying the rvalue to an lvalue is the preferred choice (in some cases you can bind an lvalue reference to const to achieve a similar effect): r-value references are designed to be the subject of a move-constructor or move-assignment. Open the project's Property Pages dialog box. If T is non-void, then the parameter is the T (or possibly an rvalue or const lvalue reference to T) with which to initialize the wrapper. Therefore, I will not jump right in and explain what rvalue references are. Put simply, an lvalue is an object reference and an rvalue is a value. It is very easy to preserve the "lvalueness" of pre-increment: just increment the operand and return it as an lvalue. e. The reason is simple; named rvalue reference is treated as lvalue (and implicit conversion from lvalue to rvalue reference is forbidden by standard). But I do not see how it is related to the warning, please explain. So in your example, the expression to the right of the = is an expression that happens to be an lvalue. Read 5. template <class T, class Other = T> T exchange(T& val, Other&& new_val). 5. Set the Enforce type conversion rules property to /Zc:rvalueCast or. I think I'm missing something basic regarding the lvalue-to-rvalue standard conversion. I would respect the first compiler more, it is at least honest with its inefficiency. The expression 0 is. You are returning a copy of A from test so *c triggers the construction of a copy of c. 4. 5. X& r = X(99); // ERRORI use forward declaration here to pass object of class B as parameter in class A. I'm a bit confused about lvalue and rvalue bindings, I have the following code:. 3) If new_type is an rvalue reference type, static_cast converts the value of expression to xvalue. When you create a std::reference_wrapper<int> and pass it in, rvalues of that type can convert to int&. int&& x = 3; x is now 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. In C++, an rvalue is a temporary object that does not have a stable location in memory. The Microsoft documentation is wrong. You might want to use it more than once in your constructor, so it shouldn't be moved from on first use unless you explicitly want to. That works well with normal variables but uint8Vect_t(dataBlock. So are character literals, such as 'a'. The result is an lvalue if T is an lvalue reference type or an rvalue reference to function type (8. C++ pass parameter by rvalue reference if possible, otherwise copy the lvalue reference. Lvalue-to-rvalue conversion. The returned lvalue will contain exactly the result it is supposed to. thanks a lot! I've just another question for you. The implicitly defined copy constructor takes an lvalue reference (i. , [expr. This ensures that you never actually modify the original this value. An lvalue-to-rvalue conversion is a conversion from a non-function, non-array lvalue or xvalue of type cv T to a prvalue of either type cv T if T is a class type or T if T is not a class type. But in the circumstances of the linked question, the template instantiation of std::function cannot be inferred from the lambda type. Compiled with "g++ -std=c++0x". 99 * @return The parameter cast to an rvalue-reference to allow moving it. So in terms of the type analogy this means that cv T& and cv T&& are transformed to cv T if T is a class type and to T if T is a non-function non-array. r can be bound to the conversion result of e or a base class of e if the following conditions are satisfied. This example might clarify it: 16. Every expression is either an lvalue or an rvalue, so, an rvalue is an expression that does not represent an object occupying. In fact, that's the origin of the names: an lvalue was (originally) anything that could appear on the Left side of an assignment, and. uint8Vect_t encodeData(uint8Vect_t &dataBuff); Here you are taking a reference to a uint8Vect_t. returning either a rvalue or an lvalue. for efficient. An lvalue reference (commonly just called a reference since prior to C++11 there was only one type of reference) acts as an alias for an existing lvalue (such as a variable). rvalue — The expression that refers to a. g. For non-class types you cannot assign to rvalues. From the linked documentation. C++ (as opposed to C) is a devoted lvalue-preserving language: it strives to painstakingly preserve the "lvalueness" of an expression whenever it is possible. 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. 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. 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. If I understand correctly what do you want, you can use std::reference (to wrap a l-value reference so that std::make_tuple() produce std::tuple with a reference in the corresponding position), and std::forward, to get the correct type of reference from a variadic list of arguments. c++ base constructor lvalue to parameter. I could have used std::move to convert the lvalue to rvalue reference and the call would be successful. rvalue references are considered lvalue (this part I understand) They are not. So, the conversion from a A rvalue to something that P&& would accept in (1) calls the user defined conversion function operator P() &&. for the same reason as that example. static_cast can do other things, as listed in 5. 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. If T is an incomplete type, a program that necessitates this conversion is ill-formed. Using lvalue references where rvalue references are required is an error: int& func2(){//compilation error: cannot bind. 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. 1. lvalue cannot be a function, expression (like a+b) or a constant (like 3 , 4 , etc. C++03, section §3. 1. 3. assign values to the reference return type directly in c++. The terms are somewhat language-specific; they were first introduced in CPL. Forwarding references are very greedy, and if you don't pass in the. Applying the lvalue-to-rvalue conversion to x reads the value of the mutable global variable globx, which makes it not a constant expression as the value of globx is subject to change (and, even if it were const, there would be the issue of its value not being known at compile time). b is just an alternative name to the memory assigned to the variable a. 3=i; is illegal. 区分左值和右值是很重要的，这是使用C++11 move语义的基础。. h, the output is same as Clang output it's reasonable. Conversely, d = static_cast<float> (j)/v; produces an. Lvalue and rvalue are expressions that identify certain categories of values. lvalues and rvalues lvalue –writable memory location; has an address int a; rvalue –data at readable memory location or readonly value that doesn’t have an address Transient (temporary) variable (register, means that we cannot change it’s value in C/C++, only to fetch) constant (including addresses) 5 = a; //An rvalue is a type of expression, not a type of object. Category 4 used to be a bit different in C++11, but I believe this wording is correct for C++14. So. 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. But instead removing either reference overload results in ambiguity with f( int ). In particular, only const_cast may be used to cast away (remove) constness or volatility. It seems like std::array can be converted to an std::span when it's an rvalue only on clang. 10/2), Whenever a glvalue appears in a context where a prvalue is expected, the glvalue is converted to a prvalue. 3. 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. 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. Each expression is either lvalue (expression) or rvalue (expression), if we categorize the expression by value. have lvalues passed by reference). I expect that when using a temporary instance of a Wraper object, the conversion operator defined for rvalue will always be used. rvalues can bind to rvalue references and const lvalue references, e. This is a helper function to allow perfect forwarding of arguments taken as rvalue references to deduced types, preserving any potential move semantics involved. arg the variable has type int&& and no value category. Every lvalue is, in turn, either modifiable or non-modifiable. , Circle c3 (Circle (4)), I'd expect the third constructor, (copy constructor with rvalue referecne) to be called but it's not the case. It is VC++'s evil extension. LIU 153 6 10 What. Lvalue-to-rvalue conversion C++. The value of x is 1. This implies that the compilers that accept the above code without a diagnostic are non-conforming (i. Their very nature implies that the object is transient. Would you ever mark a C++ RValue reference parameter as const. Both of these options are user-defined conversion functions, so neither is better in terms of overload resolution, thus an ambiguity. Each C++ expression (an operator with its operands, a literal, a variable name, etc. 6. OK. I. Then I use rvalue reference of class B's this pointer to pass it to A's constructor. an rvalue reference). Overload resolution is used to select the conversion function to be invoked. The r-value reference is a reference to the original object, so converting it to a l-value reference will just make a reference to the original object. Found workaround how to use rvalue as lvalue. That's right according also to the C++ Standard (talking about the lvalue-to-rvalue conversion): 4. Note that by binding a temporary to a rvalue-reference (or a const. 3. Does template argument resolution convert L-values to R-values or like how does this work? c++; c++11; templates;. 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. test prep. Lvalue reference and rvalue reference are both types; because the names are so similar, it is easy to confuse the two. Through an lvalue to rvalue conversion. That being said, and assuming you don't want to overload doStuff (otherwise see Hinnant's answer), you can write a utility. Radius: 2 2 4. Note that when we say lvalue or rvalue, it refers to. Getting into all the details of the various value categories isn't going to be at all helpful to a beginner and will just serve to confuse and discourage. The problem is that your method of differentiating lvalues from rvalues with func is. 98 * @param __t A thing of arbitrary type. xvalue always refers to an expression. ) is characterized by two independent properties: a . Is there a way to write a function in C++ that accepts both lvalue and rvalue arguments, without making it a template? For example, suppose I write a function print_stream that reads from an istream and prints the data that was read to the screen, or something. 1 Answer. 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. lvalue:-. One that returns an int used when a rvalue is needed. An lvalue may get converted to an rvalue: that's something perfectly legit and it happens quite often. A void * value resulting from such a conversion can be converted back to the original function. 2. ; In all other cases, the cast result is a (prvalue) rvalue. When C++11 invented rvalue references, none of this behavior changed at all. Otherwise, the type of the prvalue is T. From C++11 4. C++0x rvalue reference template argument deduction. That means you can't call non-const functions on the object, but if you want to pass rvalues such as temporaries, then calling non-const functions wouldn't necesarily make much sense anyway. ref]/5. 0. This isn't strictly true in all cases; in unevaluated. e. Select the Configuration Properties > C/C++ > Language property page. Note that by binding a temporary to a rvalue-reference (or a const reference) you extend its lifetime. foo now is null. And an identifier "is an lvalue if the entity is a function or variable" (5. The locator value is called lvalue, while the value resulting from evaluating that location is called rvalue. This approach is hard to generalize to more input arguments. const foo&& can only bind to an rvalue, but const foo& can bind to both lvalues and rvalues. Assuming C++11 or later:. There is no implicit conversion as suggested in the title, the reference binds directly to the. Rvalue references are a feature of C++ that was added with the C++11 standard. A modifiable lvalue may be used as the first (left) argument of the built-in assignment operator. Share. reinterpret_cast reinterpret_cast converts any pointer type to any other pointer type, even of unrelated classes. Thus, this syntax is now legal: T&& r = T(); rvalue references primarily provide for the following: Move semantics. Therefore, if we make a reference parameter const, then it will be able to bind to any type of argument:According to the rvalue reference proposal, a named rvalue is no different from an lvalue, except for decltype. As with all cast expressions, the result is: an lvalue if target-type is an lvalue reference type or an rvalue reference to function type(since C++11) ; an xvalue if target. Move semantics relies on a new feature of C++11, called rvalue references, which you'll want to understand to really appreciate what's going on. 0) is not permitted in a core constant expression unless it meets one of three listed criteria (see C11 5. For details, see Set C++ compiler and build properties in Visual Studio. Types shall not be defined in a reinterpret_cast. (Lvalue-to-rvalue conversions on class types are rare, but do occur in some places in the language, e. 9. オブジェクトという言葉が聞き慣れないなら. a non-const reference). It cannot convert from an rvalue to an lvalue reference, even a const one. e. As we've seen earlier, a and b are both lvalues. [ Note: If T is a non-class type that is cv. Variables of type rvalue reference have to be initialized in their definition like variables of type lvalue reference. The issue in both cases (extracting a pointer from a const lvalue and extracting an lvalue from an rvalue reference) is that it's the. If I change func (unsigned int&) to func (Color&), compiler accept it. Hot Network QuestionsSorted by: 19. In any assignment statement “lvalue” must have the capability to store the data. With argument deduction, parameter of make_tuple is deduced to be: int&, and in this case i can be bound. But the third one steals the goalKeeper object of t. The answer lies in the second property of expressions: the value category. 2), an xvalue if T is an rvalue reference to object type. Because a non-const reference is always a lvalue, so the code works and result in a lvalue (i. The rvalue-reference version can't be called with an lvalue argument. As @IgorTandetnik said - anything with a name can be assumed an lvalue. And it's on the value level that talking about rvalue/lvalue-ness makes sense (after all, those are called value categories). (This is somewhat of a simplification, in C++11 we have lvalues, xvalues and prvalues. Only the following conversions can be done with const_cast. The new version creates a temporary of type double for the conversion int -> double and binds. The addition operator + (and all other binary operators) requires both operands to be rvalue, and the result is rvalue. 2k 9 128 212 asked Jan 14, 2016 at 8:26 Simon X. However, as far as class objects are concerned. That is special syntax for a so-called forwarding reference. If the type is a placeholder for a deduced class type, it is replaced by the return type of the function. You could disallow rvalues, but not sure if that would be acceptable. This is its value category. Conversion of a function pointer to void * shall not alter the representation. That's an exception to the general rule that it is impossible for lvalues to be bound to rvalue. If the function argument is an rvalue, the compiler deduces the argument to be an rvalue reference. This would seem to be possible since there is a std::vector::push_back(value_type&& val) function. (until C++11) When an lvalue-to-rvalue conversion is applied to an expression E, the value contained in the referenced object is not accessed if: In general, lvalue is: Is usually on the left hand of an expression, and that’s where the name comes from - “left-value”. thus, this is legal: string&& s = foo (); // extends lifetime as before s += "bar"; baz (std::move (s)); // move the temporary into the baz function. Jun 27 at 7:34. . lvalueとrvalueとは いずれもオブジェクトだ 。. This is a follow-on question to C++0x rvalue references and temporaries. 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. Follow. However what matters here is the expression and: Each C++ expression (an operator with its operands, a literal, a variable name, etc. lvalue references are marked with one ampersand (&). Type conversions on references. Note that there is one exception: there can be lvalue const reference binding to an rvalue. If this was allowed, then it would look something like: The expression i in increment(i) is casted to an rvalue via lvalue-to-rvalue conversion. Note that this must wait until construction is complete for two reasons. You have to pass pointer to smart pointer, and pointer can have any type - lvalue/rvalue. 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. e. You will often find explanations that deal with the left and right side of an assignment. A conditional expression can be an lvalue or an rvalue. But then i got following error:. So: since foo () returns a reference ( int& ), that makes it an lvalue itself. 12. Whether it’s heap or stack, and it’s addressable. This article also mentioned that issue. An lvalue is, according to §3. Ternary conditional operator will yield an lvalue, if the type of its second and third operands is an lvalue. On the other hand lvalue references to const forbids any change to the object they reference and thus you may bind them to a rvalue. The implementation of the language level is based on IBM's interpretation of the standard. 8. 1 Answer. These get their names from the types of items that can go on the left-hand-side and right-hand-side of an assignment statement. b is just an alternative name to the memory assigned to the variable a. lval), array-to-pointer (conv. , buggy). However, it's type will be const std::string or std::string depending on the choice of const in the MyPair type. It's been part of the language since the beginning. Yes, rvalues are moved, lvalues are copied. If the target (or, if the conversion is done by user-defined conversion, the result of the conversion function) is of type T or derived from T, it must be equally or less cv-qualified than T, and, if the reference is an rvalue reference, must. If you would fix the copy constructor to: DriverPoint(const DriverPoint& driverPoint) both adding lvalue and adding rvalue to the vector by calling push_back would work, but both would go through the copy ctor and not through move, as you didn't implement move and the default move is implicitly deleted if you declare any single one. lvalues and rvalues are expression categories, not flavours of object. So a class that doesn't support move semantics will simply do a copy instead. This article Understanding lvalues and rvalues in C and C++ probably is one of the better detailed explanations. But you can take the address of an array, as with &arr. 1 Answer. There is a very important distinction to be made between expressions which are rvalues and expressions whose type is an rvalue reference. C++ 中有两种类型的表达式：. Secondly, the compiler will look for a move assignment operator or copy assignment operator implementation then, failing that, will fall back to the copy constructor which has been implemented. — Otherwise, the reference shall be an lvalue reference to a non-volatile const type (i. c++11 decltype returns reference type. 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. The C++ Standard does use the term rvalue, defining it indirectly with this sentence: "Every expression is either an lvalue or an rvalue. The second are value categories for expressions.