The code details resulting from the design are that the function should have private access only, but that's a secondary concern. You can't bind a temporary to a non-const lvalue-reference because it doesn't make much sense to modify, say, a literal like 42. Both const and non-const reference can be binded to a lvalue. Value categories are applied to expressions, not objects. The advantage of rvalue references over lvalue references is that with rvalue references you know that the object referred to is an rvalue. If the initializer expression. int& func() { int x = 0; return x; } compiles, but it returns a reference to a stack variable that no longer exists. Given all three functions, this call is ambiguous. Non-compliant compilers might allow a non-const or volatile lvalue reference to be bound to an rvalue. Returning non-const lvalue reference. However, lvalue references to const forbid any change to the object and thus you may bind them to an rvalue. 4. The reference returned from get_value is bound to x which is an l-value, and that's allowed. A function parameter such as T&& t is known as a forwarding reference. The literal 0 is still a poor choice for its default value, considering that 0 is an int, and your type is. A non-const reference may only be bound to an lvalue[/quote] 1 Reply Last reply Reply Quote 0. Take pointers by value -- T const*-- and things are more sane. Properties -> C/C++ -> Language. It's the first const that I'm unsure of. Sometimes even for the original developer, but definitely for future maintainers. Of course the left value of an assignment has to be non-const. References to non-pointer values make more sense. Case 3: binding to data members. error: invalid initialization of non-const reference of type 'int&' from an rvalue of type 'int' GCC complains about the reference not being const, namely a constant. obj in f is an lvalue expression, and will therefore be treated as such. Since the temporary B that's returned by source () is not. The following code fragment illustrates the binding preferences: Why do we use rvalue reference in reference wrapper? Because reference_wrapper is only meant to store references to lvalues, the standard disables. There are better ways to solve your problems. e. only call const members of the object, you can not implicitly convert it to non-const, and you cannot perform non-const operations on its members. I'll try paraphrasing it: In compiler version 2002, if the compiler had the choice if it would transform an object returned by a function to a non-const-reference or another type, it would have chosen the non-const-reference. initial value of reference to non-const must be an lvalue, Passing an object type by. C++/SDL "initial value of reference to a non-const must be an lvalue". Furthermore, we don't know if somefunc2 modifies the referenced byte, and if it does then we don't know what should happen to the other byte. 2) persists until the completion of the full-expression containing the call. rvalues can be residing on read-only memory spaces where changing them might not be allowable and hence the compiler prohibits them. e. I do not quite understand why there is a warning A non-const reference may only be bound to an lvalue? A const reference can be bound to: R-value L-value A non-const reference can be bound to: L-value This means that you can do this: int const &x = 5; But you _can't_ do this: int &x = 5;, thus preventing you from trying to modify a literal, or. You signed out in another tab or window. An lvalue (pronounced “ell-value”, short for “left value” or “locator value”, and sometimes written as “l-value”) is an expression that evaluates to an identifiable object or function (or bit-field). You can also simplify the return expression, and make the method const, since comparing two objects should not change either of them: bool String::operator< (const String & obj) const { return strcmp (*this, obj) < 0; } although I am not sure strcmp can deal with two. The compiler automatically generates a temporary that the reference is bound to. Constructor by the definition does not have a return value. warning C4239: nonstandard extension used: 'default argument': conversion from 'std::shared_ptr' to 'std::shared_ptr &'. If you compile with the /Wall flag, you will be given the answer by the compiler itself:. @YueZhou Function lvalues may be bound to rvalue references. Good article to understand both lvalue and rvalue references is C++ Rvalue References Explained. an lvalue, this constructor cannot be used, so the compiler is forced to use. You can disable this behaviour with the /Za (disable language extensions) compiler switch under. @Nater The kind of reference (const/lvalue/rvalue) is irrelevant to the lifetime extension rules. So, when you type const int& ref = 40. e, the condition. 0; // error: not an lvalue and reference not const int i = 2; double& rd3 = i; // error: type mismatch and reference not const —end example]A non-const reference may only be bound to an lvalue[/quote] 1 Reply Last reply Reply Quote 0. I recommend checking how standard library deals with this. There are exceptions, however. There are several (very constrained) circumstances in which the compiler, with language extensions enabled, will still allow a non-const lvalue reference to bind to an rvalue expression. All groups and messages. move simply returns an rvalue reference to its argument, equivalent to. They can bind to const lvalue-references because then a promise has been made. The Standard says no. Notably, types of expressions (i. 2. 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. This function receives as a second parameter a const lvalue reference, this is an lvalue and then it calls to copy assignment. Saturday, December 15, 2007 4:49 AM. 2 Copy/move constructors [class. Lvalue and rvalue expressions. 2/5 in N4140): A temporary bound to a reference parameter in a function call (5. Just as if you had done: typedef long long type; const type& x = type(l); // temporary! Contrarily an rvalue, as you know, cannot be bound to a non-const reference. If t returns a local variable, then you get a dangling reference, since that variable is gone after the call. 1. ii. -hg. I have looked elsewhere on this site and read similar postings about this error: "initial value of reference to a non-const must be lvalue. Unless an object is created in the read-only section of a program, it is open for modifiction without adverse consequences. i. initial value of reference to non-const must be an lvalue. The only time that lifetime is extended is when a prvalue (or an xvalue referring to a member of a prvalue) is bound to a reference variable, and the lifetime of the prvalue is extended to that of the variable:. it is only accessing the string objects in the array that a points to, so there is no need to pass a by reference, passing it by value will work just fine: void spell(int n, string* a) Live Demo. A simple solution is: void foo (MyObject obj) { globalVec. 1/4 of N3337:. , cv1 shall be const), or the reference shall be an rvalue reference. What you want is in 40two's answer, but make sure to forward the parameter t. So in your case, you need to rewrite your. has an address). Const reference can be bounded to. Thank you. You know, just like any other use of const. The option -qlanglvl=compatrvaluebinding instructs the compiler to allow a non-const or volatile lvalue reference to bind to an. 4. Since there are some non-modifiable lvalues (so we do not always need to modify values through its reference). However,. Thus, in case of your variable b: T = int ==> T&& becomes int&& T = int& ==> T&& becomes int. Some similar case give me the reason: The C++ standard does not allow the binding of an anonymous temporary to a reference, although some compilers allow it as an extension. This seems to be well defined however (writing to a temporary value is just like writing to any value, the lifetime has no relevancy to the. And until now we've only touched what already used to happen in C++98. for an lvalue &) and one that is not qualified, the rules are such that they are effectively both qualified and hence ambiguous. However, A can be converted to an lvalue of type int, and const int is reference-compatible with int, so reference x of type const int can be bound to the conversion result of A(). In the above program, because value parameter y is a copy of x, when we increment y, this only affects y. Maybe because you're not doing anything the call is optimized away. & attr (optional) declarator. reference (such as the B& parameter in the B::B (B&) constructor) can only. The compiler will generate it for you. Constant lvalue references can be bound to all types of values, including non-constant lvalues, constant lvalues. This rule covers not only cases such as. This won't work. 5. C. const foo&& can only bind to an rvalue, but const foo& can bind to both lvalues and rvalues. If an rvalue is passed to factory, then an rvalue will be passed to T's constructor with the help of the forward function. e. Non-const reference may only be bound to an lvalue. Otherwise, the reference shall be an lvalue reference to a non-volatile const type (i. ). The simplest fix is to simply store the temporary object somewhere, first: Collider c=player. rvalues can only be bound to const lvalue references. 4. could be an AI. ref]/5:. Reference is always constant, you can't change reference. Ask Question Asked 8 years, 10 months ago. In the second case, fun () returns a non-const lvalue reference, which can bind to another non-const reference, of course. MS Visual Studio compilers have allowed binding of non- const references to temporary objects but it is not sanctioned by the standard. 4. Consider also this: the language has no way of knowing that the lvalue reference returned by the iterator's operator * or the vector's operator[] refers to something whose lifetime is bound to that of. 2nd that, nullptr is the best way to declare the optional parameter. 71. v = this->v*a. There's no difference between a bound rvalue reference and a bound lvalue reference. However, when you use a const reference to a non-const object, you are asking the compiler to not let you modify the object through that particular. In this context, binding an rvalue to the non-const reference behaves the same as if you were binding it to a const reference. thanks in advance, George. (Binding to a const reference is allowed. reference (such as the B& parameter in the B::B (B&) constructor) can only. This approach does not work for two reasons: First, because we modify the source object, we have to pass it as a non-const reference. For some convenience, the const refs were "extended" to be able to point to a temporary. first you are declaring it as const ref then you are redeclaring as non-const reference. y()); ~~~^~ What's wrong with the code, how can it be fixed, and why? I'm trying to write a. There are exceptions, however. The initializer for a const T& need not be an lvalue or even of type T. – GManNickG. Assuming standard data sizes, you have a reference to 2 bytes of data that you're trying to pass into a function that takes a reference to only 1 byte. Visual C++ is non-compliant with the standard in allowing binding of temporaries to non-const lvalue references. A non-const reference may only be bound to an lvalue[/quote] Reply Quote 0. ref]/5: — Otherwise, the reference shall be an lvalue reference to a non-volatile const type (i. (2) (since C++11) 1) Lvalue reference declarator: the declaration S& D; declares D as an lvalue reference to the type determined by decl-specifier-seq S. const A& x = 1; //compile x = 2; //error! A&& xxx = 1; //compile A& xx = 1; //does not compile. However, now you've got a temporary A, and that cannot bind to a, which is a non-const lvalue reference. To be standards compliant, you need. By float&, he means he wants to take a reference to a float. (I'll comment on all the answers. . You can normally hide the expression template type behind private members. Hence, C++ does not permit a non-const reference to a const variable. have a good weekend, George. 1 Answer. I can't understand why I have to specify the dynamic type to make it work. You can correct the cases where the message is emitted so that your code is standard compliant. add (std::move (ct)); } A forwarding reference can bind to both lvalues and rvalues, but. g. The implication of a function that takes a non-const reference as an argument is that there is a side-effect applied to the value of that argument. Specifically, a const rvalue will prefer to bind to the const rvalue reference rather than the const lvalue reference. Because a reference to a non-const value can only bind to a modifiable lvalue (essentially a non. Sometimes even for the original developer, but definitely for future maintainers. 4. at returns a proxy (of type std::vector<bool>::reference) that allows you to write the element. But an rvalue reference can't bind to an lvalue because, as we've said, an rvalue reference refers to a value whose contents it's assumed we don't need to preserve (say, the parameter for a move constructor). Case 3: binding to data members. its address could be got). It is a name of a reference, and references refer to objects. 3 -- Lvalue references ), we discussed how an lvalue reference can only bind to a modifiable lvalue. If t returns by lvalue reference, the code does not compile because a rvalue reference cannot bind to it. name. In the following codes, I have two versions of class A instantiated, one is bound to int and the other to int&. , cv1 shall be const), or the reference shall be an rvalue reference. 3. a copy would be needed). The ability you're talking about is exactly why forwarding references exist: so that the copy/move aspects. VS2008 is not too bad as at least it gives a compile warning: warning C4239: nonstandard extension used : 'initializing' : conversion from std::string to std::string & A non-const reference may only be bound to an lvalue A non-const reference may only be bound to an lvalue. The core of your question is: can rvalues be bound to non-const lvalue references?. int & a=fun (); does not work because a is a non-const reference and fun () is an rvalue expression. 2. 12. In the case of built-in types, the result is a prvalue, so a temporary (of type const int) is always created from this prvalue and bound to x. (An xvalue is an rvalue). v; return res; } You should make the member function a const member function too since it does not modify the object. initial value of reference to non-const must be an lvalue. Improve this question. Neither the proxy object, nor the converted bool (which is a prvalue) can be bound to a bool& as you try to do in the return statement. The const subscript operator returns a const-reference, so the compiler will prevent callers from inadvertently mutating/changing the Fred. For example, the argument might be a reference to a node of a linked list, and within the function you may want to traverse the list, so you will want to be doing node = * (node. An rvalue reference can only bind to non-const rvalues. What getPtr () return: std::shared_ptr<int> getPtr (int val) { } is an rvalue reference. This rule does not reflect some underlying. A non-const reference may only be bound to an lvalue. it doesn't say anything else. I don't get why the make_range function doesn't work unless I remove the View (View<C>& r) constructor. We can't bind non-const lvalue reference to an rvalue, but it can be bound to the const one. — Otherwise, the reference shall be an lvalue reference to a non-volatile const type (i. (PS the lifetime of the temporary is extended to the lifetime of the reference. The only difference (that I see) is that x2 knows it only has 3 rows, whereas x1 has a dynamic number of rows. It's just that non-const lvalue references can't bind to rvalues, so the can never be used that way. e. If it is not immediately obvious, we can try to check: Therefore, you can opt to change your getPtr ()'s return to a non-const lvalue reference. How to fix depends on what the return type of cleverConfig. operator[] is - either change the return type of the function from Value* to const Value&, or return *cleverconfig[name];The C++ Standard (2003) indicates that an rvalue can only be bound to a const non-volatile lvalue reference. The Rvalue refers to a value stored at an address in the memory. Fibonacci Series in C++. an int literal) is not a lvalue, so int &p=255 fails. A reference is supposed to work a lot like a pointer in a sense. Are there specific scenarios where binding temporary to non-const reference is allowed. thanks in advance, George. Reference-compatibility allows extra cv-qualifications in the reference type. copy. Secondly, your variable is const (as it is constexpr), and a non-const reference cannot be bound to a const object. If you used a reference to const, it would extend the lifetime of the temporary result of the implicit conversion: const int * const &j = i;The iterator object itself refers to an element of the container. h(418) : warning C4239: nonstandard extension used : 'argument' : conversion from 'XUTIL::xList<T>::iterator' to. The only way to safely bind an rvalue to an lvalue is either by. cannot bind non-const lvalue reference of type to an rvalue of type 0 Implementation of the decorator class in C++ using a member reference to the decorated object not working as expected 12. Const reference can be bounded to. Allowing both rvalues and lvalues to be bound to an lvalue reference makes that impossible. clang++ says: " error: non-const lvalue reference to type 'class foo' cannot bind to a temporary of type 'class foo'" Change foo. for example, to get a reference to the element. 6. An lvalue reference is declared using the & operator, for example int& . My understanding is that this is largely to avoid breaking several enormous legacy codebases that rely on this "extension. 0f, c); The other similar calls need to be fixed too. Now it makes actually sense to take its address, as it is an lvalue for all intents and purposes. You switched accounts on another tab or window. Actually the precise reason it doesn't work is not because temporaries cannot be bound to non-const lvalue references, but rather that the initializer of a non-const lvalue reference is subject to certain requirements that char const[N] cannot meet in this case, [dcl. h"` displayPNG("solve. In the case of int inner(). By default, or if /Zc:referenceBinding- is specified, the compiler allows such expressions as a Microsoft extension, but a level 4 warning is issued. It can appear only on the right-hand side of the assignment operator. Temporary objects cannot be bound to non-const references; they can only. If C++ allowed you to take literals by non-const reference, then it would either: Have to allow literals to change their meaning dynamically, allowing you to make 1 become 2. Some compilers allow int &r = 5; as an extension, so it makes sense, it's just not allowed by the standard. cannot bind non-const lvalue reference of type to an rvalue of type 0 Implementation of the decorator class in C++ using a member reference to the decorated object not working as expected12. 3. int&& x = 10; is a declaration and not an expression. 0 Invalid initialization of non-const reference from a. Notes: A non-const or volatile lvalue reference cannot be bound to anrvalue of a built-in type. Since the temporary B that's returned by source () is not. decltype (fun ()) b=1;Syntax: void foo (std::string& str); // non-constant lvalue reference overload. three rules on bit-fields: Rule 1, "A bit-field shall not be a static member. But a more proper fix is to change the parameter to a const reference:However, you might need at that returns non-const reference too. To handle other value categories, one may use std::forward_as_tuple:. Here you are taking a reference to a uint8Vect_t. It looks like well formed code with defined behavior to me. void my_function (const MyType & arg); This avoids the copy of these parameters in situations where they don’t need to be copied. A const reference prolongs a lifetime of a temporary object bound to it, so it is destroyed only when the reference goes out of scope. test (const std::string& a): a is const lvalue reference and like before I have lvalue and rvalue. There is no such thing as a const rvalue, since an rvalue permits a "destructive read". A reference (of any kind) is just an alias for the referenced object. Only a named modifiable object. That's not it. 2) x is a variable of non-reference type that is usable in constant expressions and has no mutable subobjects, and E is an element of the set of potential results of an expression of non-volatile-qualified non-class type to which the lvalue-to-rvalue conversion is applied, or. In fact, in terms of overload resolution, an rvalue prefers to be bound to an rvalue reference than to an lvalue const reference. . Any reference will do. What std::string::c_str returns is an rvalue, which can't be bound to an lvalue-reference to non-const (i. @KerrekSB: Binding a temporary to a const reference can cause a copy construction. Troubles understanding const in c++ (cannot bind non-const lvalue reference) 0. Similar rationale is applied to the const qualifier. Just like how we don't want the first example to create a temporary int object (a copy of x) and then bind r to that, in the. A temporary is a prvalue whilst a reference is a lvalue. double && does not work for lvalues. In contrast you can bind const references to temporary values as in: std::string const & crs1 = std::string (); However the following is illegal: std::string & rs1 = std::string (); Don't pass int&, it can't be bound to a constant or temporary because those can't be modified - use const int& instead. View Site LeadersThe result is an lvalue if T is an lvalue reference type or an rvalue reference to function type (8. Your declaration of a is a non-const lvalue reference,. int & a=fun(); does not work because a is a non-const reference and fun() is an rvalue expression. In this case, returning a non-const lvalue reference compiles because x is an lvalue (just one whose lifetime is about to end). The unary & operator gets a pointer to a variable. const reference to non-const object. Pass by reference can only accept modifiable lvalue arguments. std::string&& rref = std::string("hello"); rref has value category lvalue, and it designates a temporary object. It's not against the rules in C++ to use a non-const reference but I think it lends to massive confusion and potential bugs. The compiler automatically generates a temporary that the reference is bound to. 5. I do not quite understand why there is a warning A non-const reference may only be bound to an lvalue? A const reference can be bound to: R-value L-value A non-const reference can be bound to: L-value This means that you can do this: int const &x = 5; But you _can't_ do this: int &x = 5;, thus preventing you from trying to modify a. Although the standard formulates it in other words (C++17 standard draft [dcl. GetCollider (). for example, to get a reference to the element. 3) non-const lvalues can be passed to the parameter. obj & a1 = bar(); invalid initialization of non-const reference of type ‘obj&’ from an rvalue of type ‘obj’ using g++. What you were trying to do isn't much different from writing a function that takes a mutable reference to int (e. The problem is that auto and decltype side-step the whole public/private thing, allowing you to create types that you. Ok, so, I already know that returning a local variable as reference will cause undefined behavior when we try to use it and that we can create a non-const reference to only form a lvalue variable. A temporary can only bind to const lvalue references, or rvalue references. find (key);A pointer to non-const is convertible to pointer to const however. 3. You obviously can't point to a temporary. 1. of the Microsoft compiler. Unlike a reference to non-const (which can only bind to modifiable lvalues), a reference to. Without the function, you are essentially writing: int x = 10; // x is an l-value int &get_x = x; // just a variable instead of a function get_x = 20; // assignment is ok By float&, he means he wants to take a reference to a float. thus, this is legal: string&& s = foo (); // extends lifetime as before s += "bar"; baz (std::move (s)); // move the temporary into the baz function. EX: int &var=4; we can change value of reference , but logically it is not possible to change 4. But if you are asking why this doesn't. Return by value. But the principle is the same. rvalue Reference Cannot Bind to a Named lvalue. Hence, B::B (A) will be selected, because there is a conversion from B to A. An lvalue reference is a reference to an object that has a distinct memory address and can be modified. It seems perfectly reasonable for the standard to have been that a temporary is created, and dropped at the end of the function's execution (as you currently have to manually do). name. ctor] A non-template constructor for class X is a copy constructor if its first parameter is of type X&, const X&, volatile X& or const volatile X&, and either there are. What this means is that it's technically possible for the function to modify the pointer itself in a way that gets propagated to the caller. Non-compliant compilers might allow a non-const or volatile lvalue reference to be bound to an rvalue. GetCollider(). cpp struct S { }; void f(S&) { } S g() { return S {}; } int main() { S& s = g (); // warning C4239 at /W4 const S& cs = g (); // okay, bound to const ref f (g ()); // Extension: error. Oct 10, 2013 at 22:07. In the second case, fun() returns a non-const lvalue reference, which can bind to another non-const reference, of course. Overload between rvalue reference and const lvalue reference in template. What you probably want is: BYTE *pImage = NULL; x. For details of the rvaluereferences feature, see Using rvaluereferences (C++11). CheckCollision (0. a nonconst reference could only binded to lvalue. std::vector<bool> does not return a bool&, but nevertheless this is completely fine: std::vector<bool> x{0,0,0}; x. "non-const lvalue reference to type 'QByteArray' cannot bind to a temporary of type 'QByteArray'". Sorted by: 6. Assume a variable name as a label attached to its location in memory. e. First of all, I will post the warning I'm getting: xlist. int const&x = 42; // It's ok. Jun 17, 2016 at 3:16. A variable is an lvalue, so you are allowed to bind a non const reference to it. We should not mix rvalue and lvalue references. ) Thus the return type is also int&. 5 The first option can take lvalues because it's an lvalue reference. Since the temporary B that's returned by source () is not. @relent95 Yes, whether the id-expression refers to a variable of reference or non-reference type doesn't matter because of what you quoted. 3/5:. All (lvalue, rvalue, const, non-const) -> const lvalue. This section presents an intentionally simplified definition of lvalues and rvalues. However, there is a canonical mapping from the. " I really need some further explanations to solving this: Non-const references cannot bind to rvalues, it's as simple as that. Some compilers allow int &r = 5; as an extension, so it makes sense, it's just not allowed by the standard. : if at least one operand is of class type and has a conversion-to-reference operator, the result may be an lvalue designating the object designated by the return value of that operator; and if the designated object is actually a temporary, a dangling reference may result. 80). MSVC has an "extension that allows that. Non-explicit constructors have their uses. An expression that designates a bit-field (e. e. Non-const reference may only be bound to an lvalue. 11. Return by value. Follow. However, now you've got a temporary A, and that cannot bind to a, which is a non-const lvalue reference. Non-const reference may only be bound to an lvalue. But since it's a non-const reference, it cannot bind to an rvalue. And an rvalue reference is a reference that binds to an rvalue. Assume a variable name as a label attached to its location in memory. The rest of the article will elaborate on this definition. I do not quite understand why there is a warning A non-const reference may only be bound to an lvalue and 'B::B (A)' called instead of 'B::B (B &)'? think. png", 560, 120); int x2 = 560 + 54; int x1 = 560; int y1 = 120; int y2 = 291 + 120; const int * xSolv2 = &x2. Apparently, the Standard agrees. 1. 3 of the C++11 standard: It doesn't allow expressions that bind a user-defined type temporary to a non-const lvalue reference. Both const and non-const reference can be binded to a lvalue. Other situations call for other needs, but today we will focus on constant references. x, a. Another example:In the example above, SomeClass() is not bound to an identifier, so it is an rvalue and can be bound to an rvalue reference -- but not an lvalue reference. – The outcome is that the code compiles and works when using MSVC, but doesnt on GCC and Clang, with respective errors: GCC: cannot bind non-const lvalue reference of type 'FuncPtr<bool ()>&' to an rvalue of type 'FuncPtr<bool ()>' Clang: no matching constructor for initialization of 'A'. If you want to capture the reference you need to declare a reference. A non-const reference may only be bound to an lvalue[/quote] 1 Reply Last reply Reply Quote 0. C++0x에는 rvalue reference라는 개념이 추가 됩니다. Its . A const lvalue reference or rvalue reference can be. 1. C++ does not give that feature to non-const references: A function lvalue; If an rvalue reference or a non-volatile const lvalue reference r to type T is to be initialized by the expression e, and T is reference-compatible with U, reference r can be initialized by expression e and bound directly to e or a base class subobject of e unless T is an inaccessible or ambiguous base class of U. (The small difference is that the the lambda-expression is converted to a temporary std::function - but that still can't be bound to a non-const reference). It's not against the rules in C++ to use a non-const reference but I think it lends to massive confusion and potential bugs. If encodeData() does not change dataBuff then the simplest solution is to take a const & which can bind to a temproary. cannot bind non-const lvalue reference of type to an rvalue of type. Now consider the second call site, with the temporary value: MyClass myObject{std::string{"hello"}}; myObject. It can take rvalues because it is marked const and rvalues are allowed to bind to const lvalue references. It's the specific case where changing T& to const T& does more than just ban modifications. Data members: Never const. and if you pass it to a function that takes a reference to a non-const - it means that function can change the value. Share. Follow edited May 23, 2017 at 11:55. Value categories pertain to expressions, not objects. Reload to refresh your session. The binding rules for rvalue references now work differently in one. Don't pass int&, it can't be bound to a constant or temporary because those can't be modified - use const int& instead. If binding to a non-constant rvalue is allowed, it will lead to a very dangerous situation, because a non-constant rvalue is a temporary object, and a non-constant lvalue reference may use a temporary object that has been destroyed. Viewed 3k times. Now, when printValue(x) is called, lvalue reference parameter y is bound to argument x. You're not modifying the given pointer, so just pass it by value instead of by reference. – Joseph Mansfield. g.