The Standard says no. I dont know if its bug in compiler or is it intended. Let's look at std::vector for example: reference at( size_type pos ); const_reference at( size_type pos ) const; Would you look at that. Only a named modifiable object. Non-const reference may only be bound to an lvalue. Returning non-const lvalue reference. has a class type. When I discovered this, it seemed odd to me, so I tried. Now, when printValue(x) is called, lvalue reference parameter y is bound to argument x. constexpr T& value() &; constexpr const T & value() const &; constexpr T&& value() &&; constexpr const T&& value() const &&; What is the point of returning a const rvalue reference? The only reason I can think of is to enable the compiler to help catch undefined behavior in (really really weird) cases like the followingA non-const reference may only be bound to an lvalue[/quote] Reply Quote 0. initial value of reference to non-const must be an lvalue (emphasis mine). 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. There are two aspects to the const in C++: logical constness: When you create a variable and point a const pointer or reference to it, the compiler simply checks that you don't modify the variable via the const pointer or reference, directly or indirectly. a. A const reference could be bound to rvalue, and for this case, a temporary int will be created and initialized from 255. If an rvalue is passed to factory, then an rvalue will be passed to T's constructor with the help of the forward function. – 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'. and not. My understanding is that this is largely to avoid breaking several enormous legacy codebases that rely on this "extension. match. , you may only want to hold on to a const Bar*, in which case you then can also only pass a const Bar*) Using a const Bar& as parameter type is bound to result in a runtime crash sooner rather than later because:The C++ Standard (2003) indicates that an rvalue can only be bound to a const non-volatile lvalue reference. To be standards compliant, you need. e. i. 5. Non. having an address). for example, to get a reference to the element. In other words, in your first example the types actually do match. Thus, the standard allows all types. And since that the converted initializer is an xvalue not prvalue, [conv. Is it for optimization purposes? Take this example:By overloading a function to take a const lvalue reference or an rvalue reference, you can write code that distinguishes between non-modifiable objects (lvalues) and modifiable temporary values. g. const unsigned int&), (and its lifetime is extended to the lifetime of the reference,) but can't be bound to lvalue-reference to non-const (i. operator[] . e. There are exceptions, however. But since it's a non-const reference, it cannot bind to an rvalue. Change the declaration of the function GetStart like: Point & GetStart(); Also at least the function GetEnd should be changed like: Point & GetEnd(); You could overload the functions for constant and non-constant objects:It looks like we are actually able to bind temporary object to non-const reference, but only if this object. It isn't "hard to spell type"; the compiler will prevent you from using the type explicitly. They can bind to const lvalue-references because then a promise has been made. thanks in advance, George. std::vector<bool> does not return a bool&, but nevertheless this is completely fine: std::vector<bool> x{0,0,0}; x. If you are unsure what an lvalue expression is, see this answer. So the parameter list for a copy constructor consists of an const lvalue reference, like const B& x . The best option is to return by copy. warning C4239: nonstandard extension used : 'initializing' : conversion from 'foo' to 'foo &' A non-const reference may only be bound to an lvalue (note that this remains illegal in C++11) Last edited on Dec 20, 2011 at 2:37am UTC Otherwise, if the reference is lvalue reference to a non-volatile const-qualified type or rvalue reference (since C++11): If target is a non-bit-field rvalue or a function lvalue, and its type is either T or derived from T , equally or less cv-qualified, then the reference is bound to the value of the initializer expression or to its base. 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. What you're trying to perform is making a reference to a temporary value which is not allowed. If caller passes an rvalue, then there are two moves (one into parameter and another into vector). So, when you type const int& ref = 40. qual] or even [conv. then the reference is bound to the initializer expression lvalue. What std::string::c_str returns is an rvalue, which can't be bound to an lvalue-reference to non-const (i. If you want to capture the reference you need to declare a reference. rvalues can only be bound to const lvalue references. “An old special-case permits an rvalue to be bound to an lvalue reference to non-const type when that reference is the. There are exceptions, however. E may not have an anonymous union member. and if you pass it to a function that takes a reference to a non-const - it means that function can change the value. The whole idea of forwarding is to accept any value category and preserve it for future calls. Sometimes even for the original developer, but definitely for future maintainers. So the following snippet works like a charm: const int& ref = 10; // OK!C++ : Non-const reference may only be bound to an lvalueTo Access My Live Chat Page, On Google, Search for "hows tech developer connect"As promised, I have a. Both const and non-const reference can be binded to a lvalue. Otherwise, the reference shall be an lvalue reference to a non-volatile const type (i. y()); ~~~^~ What's wrong with the code, how can it be fixed, and why? I'm trying to write a. There is no such thing as a const rvalue, since an rvalue permits a "destructive read". Non-const reference may only be bound to an lvalue. Since you cannot access the result of that side-effect if you are passing a temporary, then I would conclude that you're very likely doing something wrong. This extends the lifetime of the temporary: base * const &rp = (base*)p; Or bind the reference to an lvalue: base * b = p; base * &rp = b; Share. It got me quite curious. Return by value. Only expressions have values. Otherwise, the reference you get behaves more. In function 'int main()': Line 15: error: invalid initialization of non-const reference of type 'std::string&' from a temporary of type 'std::string' compilation terminated due to -Wfatal-errors. int&& x = 10; is a declaration and not an expression. 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. So if the function binds to a rvalue reference, what is seen at the end by the compiler for a certain type T is: std::is_rvalue_reference<T>::value. A non-const reference may only be bound to an lvalue[/quote] 1 Reply Last reply Reply Quote 0. 3 Answers. 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. Note that obj in g is also an lvalue expression; if the expression is a name for an object, then it's an lvalue. GetImage (iTileId, pulImageSize, a_pImage ); With the method defined as:This change is required by the C++ standard which specifies that a non-const. ;, x is an lvalue denoting a float whose value is the result of converting a to double and back. 4. Thus the declaration doesn't have a. int &a = 5; // error: lvalue cannot be bound to rvalue 5 However, we can bind an rvalue to a const lvalue reference (const reference): const int &a = 5; // Valid In this case, the compiler. Add a comment. Maybe because you're not doing anything the call is optimized away. It's the first const that I'm unsure of. Both const and non-const reference can be binded to a lvalue. int const (& crb)[3] = b; here we have reference to array of const int, we can also write const int (& crb)[3] = b; It would be the same. The option -qlanglvl=compatrvaluebinding instructs the compiler to allow a non-const or volatile lvalue reference to bind to an. The foo () function accepts a non-const lvalue reference as an argument, which implies one can modify (read/write) the supplied parameter. the first version essentially returns second of said pair directly. A C++ reference is similar to a pointer, but acts more like an alias. const int & is a const lvalue reference. After some investigation and help from the community, here is the answer:. Mar 22, 2013 at 18:39. It's just that type of that lvalue is "rvalue reference to Key ". if binding temporary to local non-const lvalue reference is allowed, you may write the code like this :. . The only way to safely bind an rvalue to an lvalue is either by marking the lvalue as const, or using a mutable rvalue reference && (introduced in C++11 believe?) Alex November 11, 2023 In the previous lesson ( 12. Const reference can be bounded to. Otherwise, the reference you get behaves more. thanks in advance, George. h"` displayPNG("solve. an rvalue could bind to a non-const lvalue reference, then potentially many modifications could be done that would eventually be discarded (since an rvalue is temporary), this being useless. Sometimes even for the original developer, but definitely for future maintainers. The concepts of lvalue expressions and rvalue expressions are sometimes brain-twisting, but rvalue reference together with lvalue reference gives us more flexible options for programming. push_back (std::move (obj)); } If caller passes an lvalue, then there is a copy (into the parameter) and a move (into the vector). 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). You can call a non-const member function on a temporary because this does not involve binding of a reference. ) But there is no way to show me how to solve it;You may modify a non-const object through a non-const reference. Otherwise, if the reference is lvalue reference to a non-volatile const-qualified type or rvalue reference (since C++11): If target is a non-bit-field rvalue or a function lvalue, and its type is either T or derived from T , equally or less cv-qualified, then the reference is bound to the value of the initializer expression or to its base. – Kerrek SB. The only difference (that I see) is that x2 knows it only has 3 rows, whereas x1 has a dynamic number of rows. U is a class type. 5) rvalues can be passed to the parameter. Anything that is capable of returning a constant expression or value. 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. However, in VS2010 I seem to be able to do so:. copy. Because a reference to a non-const value can only bind to a modifiable lvalue (essentially a non-const variable), this means that pass by reference only works with arguments that are modifiable lvalues. int x = 1000; const int &r = x; In this case, its a const reference to a non const variable. g. Improve this question. e, the condition. That works well with normal variables but uint8Vect_t(dataBlock. Other situations call for other needs, but today we will focus on constant references. But in your case the operands are different category (123 is a prvalue, a is an lvalue). A function lvalue; If an rvalue reference or a nonvolatile 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. GetCollider(). And plus more, in this case if I called. All (lvalue, rvalue, const, non-const) -> const lvalue. How to fix depends on what the return type of cleverConfig. warning C4239: nonstandard extension used: 'default argument': conversion from 'std::shared_ptr' to 'std::shared_ptr &'. ref/6] ). 4 — Lvalue references to const. In fact, in terms of overload resolution, an rvalue prefers to be bound to an rvalue reference than to an lvalue const reference. e. [2] Then, the resulting value is placed in a temporary variable of type T. There are two overloads. – n. The code below is not legal (problem with the foo_t initializer list) because: "A reference that is not to 'const' cannot be bound to a non-lvalue" How can I best achieve an. 4. Overload resolution is usually done in terms of a strict. So the first fix is to not use the wrong technique here, and accept by an lvalue reference instead:The simple answer is that you are right in essence. This section presents an intentionally simplified definition of lvalues and rvalues. v = this->v*a. Solution 1: Your problem lies here: The variable is an lvalue reference, that means it's a reference that cannot bind to temporary variables. A reference is supposed to work a lot like a pointer in a sense. So naming kInt is not deemed an odr-use as long as it. No, "returning a reference" does not magically extend any lifetime. Both const and non-const reference can be binded to a lvalue. Passing by reference, by a const reference wouldn't cost more than passing by value, especially for templates. We don't know which byte should be passed. 1. r can be bound to the conversion result of e or a base class of e if the following conditions are satisfied. I recommend checking how standard library deals with this. If t returns by lvalue reference, the code does not compile because a rvalue reference cannot bind to it. It allows you to do something like swap(a, b), and it will actually swap the values of a and b, instead of having to do swap. int global_x; void foo (int*& ptr) { ptr = &global_x; } void bar () { int local_x; int * local_ptr = &local_x; foo. An rvalue can be bound to an rvalue reference (T&&) to prolong its lifetime, and to lvalue references to const (const T&), but not to plain lvalue references (T&). @relent95 Yes, whether the id-expression refers to a variable of reference or non-reference type doesn't matter because of what you quoted. 흔히 rvalue reference와 구별하기 위해 기존의 reference를 lvalue reference라고 부릅니다. 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. 4 Why Rvalue cannot bind Lvalue reference? 18 Invalid initialization of non-const reference of type. An lvalue (locator value) represents an object that occupies some identifiable location in memory (i. v; return res; }void inc(int &n) { n++; } Consider the above function. You can pass lvalues to functions taking rvalues as arguments (tested using a C++ editor). struct S {}; f<S {}> (); // ok. I am still studying what is the reason in essence in compiler why a non-const reference can not be binded to a rvalue. As a reader pointed out, if g() returned const int instead of const T, the output would be different. So how to solve that. 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. Only local const references prolong the lifespan. and forwards messages that it receives to that object. A variable is an lvalue, so you are allowed to bind a non const reference to it. Saturday, December 15, 2007 4:49 AM. " I really need some further explanations to solving this: Non-const references cannot bind to rvalues, it's as simple as that. — Otherwise, the reference shall be an lvalue reference to a non-volatile const type (i. const reference to non-const object. a copy would be needed). 11. In this case, returning a non-const lvalue reference compiles because x is an lvalue (just one whose lifetime is about to end). It is a name of a reference, and references refer to objects. Share. Any reference will do. @MichaelKrelin-hacker: Technically not, you cannot (ever) bind a reference to a value (or compile time constant), the standard is quite explicit as to what actually happens: Otherwise, a temporary of type “cv1 T1” is created and initialized from the initializer expression using the rules for a non-reference copy-initialization (8. e. struct Foo{}; { const auto & r = Foo{}; // Foo object not destroyed at semicolon. 1. The linked page uses the words "rvalue" and "lvalue" incorrectly . 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 temporary to which the reference is bound or the temporary that is the complete object of a sub-object to which the reference is bound persists for the lifetime of the reference. Non-const reference may only be bound to an lvalue. 2), an xvalue if T is an rvalue reference to object type, and a prvalue otherwise. initial value of reference to non-const must be an lvalue. int& func() { int x = 0; return x; } compiles, but it returns a reference to a stack variable that no longer exists. Fibonacci Series in C++. Value categories are applied to expressions, not objects. References to non-pointer values make more sense. 1. You can call a non-const member function only on a non-const object. Follow. The question about a potential possibility to change a temporary object using a non-const reference. This extends the lifetime of the temporary: base * const &rp = (base*)p; Or bind the reference to an lvalue: base * b = p; base * &rp = b; Share. A reference (of any kind) is just an alias for the referenced object. And this is precisely what the compiler is telling you:. 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(). So if the function binds to a rvalue reference, what is seen at the end by the compiler for a certain type T is: std::is_rvalue_reference<T>::value. Its . Assume a variable name as a label attached to its location in memory. By float&, he means he wants to take a reference to a float. cpp(10): warning C4239: nonstandard extension used : 'argument' : conversion from '<type1>' to '<type2>' 1> A non-const reference may only be bound to an lvalue" only on warning level /W4 or above. If P is a forwarding reference and the argument is an lvalue, the type “lvalue reference to A ” is used in place of A for type deduction. could be an AI. Otherwise. E may not have an anonymous union member. , cv1 shall be const), or the reference shall be an rvalue reference. So obviously it's not portable. 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. m. In this case, when passing arr as argument the expression arr is an lvalue which is allowed to be bound to a nonconst lvalue reference and so this time it works. It's the specific case where changing T& to const T& does more than just ban modifications. That's my best guess anyway. Would you explain why you need a non-const reference that cannot bind to non-const objects?. [3] Finally, this temporary variable is used as the value of the initializer. Undefined behavior can sometimes look like it's working. I have to think for a while-_-!. 80). Universal references is a technique. Fun fact: /W3 is set. Since C++11, two kinds of references have existed - lvalue and rvalue references. 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. Rule 3, "Note: if the initializer for a reference of type const T& is. It can take rvalues because it is marked const and rvalues are allowed to bind to const lvalue references. name. According to the reference collapsing rules, "rvalue reference to rvalue reference collapses to rvalue reference, all other combinations form lvalue reference". Reference is always constant, you can't change reference. Rule: lvalue, rvalue, const or non-const objects can bind to const lvalue parameters. const int *p; - here it is pointer on const int int const *p; - here it is const pointer on int const int const *p; -. The first variant returns a reference to the actual value associated with the key test, whereas the second one returns a reference to the map element, which is a pair<const key_type, mapped_type>, i. Non-const references cannot bind to rvalues, it's as simple as that. obj & a1 = bar(); invalid initialization of non-const reference of type ‘obj&’ from an rvalue of type ‘obj’ using g++. 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 validity of. It work that way:. An expression that designates a bit-field (e. However, there is a canonical mapping from the. Secondly, your variable is const (as it is constexpr), and a non-const reference cannot be bound to a const object. In this context, binding an rvalue to the non-const reference behaves the same as if you were binding it to a const reference. Without rvalue expression, we could do only one of the copy assignment/constructor and move assignment/constructor. So if this is in the type Object:So we have a reference being initialized by an xvalue of type const foo. However, now you've got a temporary A, and that cannot bind to a, which is a non-const lvalue reference. Share. The basic idea behind references is that lvalue references bind to lvalues, and rvalue references bind to rvalues; the reference thus bound henceforth refers to the value it was bound to. Within the body of a non-static member function of X, any id-expression e (e. The simplest fix is to simply store the temporary object somewhere, first: Collider c=player. A reference to type “cv1 T1” is initialized by an expression of type. If t returns a local variable, then you get a dangling reference, since that variable is gone after the call. 71. Const reference can be bounded to. Unlike a reference to non-const (which can only bind to modifiable lvalues), a reference to. Notably, types of expressions (i. An lvalue reference is a reference to an object that has a distinct memory address and can be modified. However, an rvalue can be bound to a. A non-const reference may only be bound to an lvalue At best, it compiles for reasons of backward compatibility. Reload to refresh your session. However, you don't have double && in your code, you have U && for a deduced U. How to fix depends on what the return type of cleverConfig. 806 3 3 gold badges 12 12 silver badges 20 20 bronze badges. double && does not work for lvalues. first you are declaring it as const ref then you are redeclaring as non-const reference. It doesn't really matter. non-const lvalue reference to type cannot bind. A function parameter such as T&& t is known as a forwarding reference. This means the following. 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. Since the temporary B that's returned by source () is not. And an rvalue reference is a reference that binds to an rvalue. [ Example: double& rd2 = 2. This won't work. The Rvalue refers to a value stored at an address in the memory. The first variant returns a reference to the actual value associated with the key test, whereas the second one returns a reference to the map element, which is a pair<const key_type, mapped_type>, i. 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). 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. . . including the case where an lvalue is provided, it cannot modify its input (at least not the one bound to the x parameter) - if it did, it would violate the semantics. 68 initial value of reference to non-const must be an lvalue. One way to accomplish this is by overloading on the free parameter with both const and non-const lvalue references. e. The simplest fix is to simply store the temporary object somewhere, first: Collider c=player. e. Reload to refresh your session. Overload between rvalue reference and const lvalue reference in template. 5). A const lvalue reference or rvalue reference can be. But doesn't work when instantiated over non class types (as I expected)This change is required by the C++ standard which specifies that a non-const. decltype(fun()) b=1;Exception as noted by T. I believe the relevant Standard paragraph is 8. Once bound, there is no difference in behaviour between an rvalue reference and an lvalue reference. ) Thus the return type is also int&. Regarding the second question. In the previous lesson ( 12. 0 Invalid initialization of non-const reference from a. obj in f is an lvalue expression, and will therefore be treated as such. 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. This rule covers not only cases such as. 10 is a prvalue expression. The default is -qlanglvl. One const and the other non-const. 3. png", 560, 120); int x2 = 560 + 54; int x1 = 560; int y1 = 120; int y2 = 291 + 120; const int * xSolv2 = &x2. Understand the design first before you implement. Note that there is one exception: there can be lvalue const reference binding to an rvalue. Confusion between rvalue references and const lvalue references as parameter. C. An expression that designates a bit field (e. Now, that the prvalue has an indeterminate lifetime, it is. Because as_const doesn't take the argument as const reference. As to why using const & or even rvalue && is a bad idea, references are aliases to an object. decltype(fun()) b=1; Then, your code initializes a const reference with a prvalue of a different (non-reference-related) type. Allowing both rvalues and lvalues to be bound to an lvalue reference makes that impossible. By the way, don’t return const values from a function, because you make it impossible to use move semantics. ) Note that irr doesn't bind to iptr; so any modification on. However, int can be implicitly converted to double and this is happening. We should not mix rvalue and lvalue references. std::tie always expects lvalues for arguments, since its intended purpose is to be used in assignment. "A reference to type 'cv1 T1' is initialized" refers to the variable that is being initialized, not to the expression in its initializer. g. 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. In the second case, fun() returns a non-const lvalue reference, which can bind to another non-const reference, of course. a. (An xvalue is an rvalue). Constructor by the definition does not have a return value. 1. int x; int&& r = x; but also. 3. Saturday, December 15, 2007 4:49 AM. To produce an xvalue, i. std::string&& rref = std::string("hello"); rref has value category lvalue, and it designates a temporary object. @KerrekSB: Binding a temporary to a const reference can cause a copy construction. C++ only allows non-const binding of an lvalue to a non-const lvalue reference. g. A const lvalue reference can be initialized from a bit-field. The problem is that a non-const lvalue reference cannot bind to a temporary, which is an rvalue. Nov 15, 2016 at 14:14. 3. Assignment to references, on the other hand, is implicit, so if a is of type int& you simply need to write a=b to make a a reference to b. Sometimes even for the original developer, but definitely for future maintainers. a nonconst reference could only binded to lvalue. 6 — Pass by const lvalue reference. However, lvalue references to const forbid any change to the object and thus you may bind them to an rvalue. e. C++ : Non-const reference may only be bound to an lvalueTo Access My Live Chat Page, On Google, Search for "hows tech developer connect"As promised, I have a. Improve this question. Thank you. int a = 7. have a good weekend, George. Because a reference to a non-const value can only bind to a modifiable lvalue (essentially a non. T and U) are never reference types. Similar rationale is applied to the const qualifier. Follow edited May 23, 2017 at 11:55. 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. @Nater The kind of reference (const/lvalue/rvalue) is irrelevant to the lifetime extension rules. May 4, 2013 at 16:38. m, where a is an lvalue of type struct A {int m: 3;}) is a glvalue expression: it may be used as the left-hand operand of the assignment operator, but its address cannot be taken and a non-const lvalue reference cannot be bound to it. It never makes sense to return a dangling reference, but it's syntactically legal. 12. Am getting cannot bind non-const lvalue reference of type ‘Type&’ to an rvalue of type 'Type'The function returns a pointer, which you are trying to bind to a reference. Hot Network Questions Identifying traffic signals for colour blind peopleBut thinking further about it, I think it might be OK :-) Imagine there were three consts (not just two) in const Array &operator=( const Array & ) const; The last const is unacceptable, as it can't even modify itself. A temporary or an rvalue cannot be changed with a reference to non-const. int const&x = 42; // It's ok. Consulting the cppreference documentation for <type_traits>, it appears that there is not such a tool in the standard library. This may sound like a silly question, but I was confused about this following behaviour:. Yes, some times it is very convenient to be able to locally modify a pass-by-value argument to a function. However, you might need at that returns non-const reference too. Follow edited Nov 15, 2016 at. And const is a constraint imposed by the compiler to the variable that is declared as const. And until now we've only touched what already used to happen in C++98.