Invalid initialization of non-const reference of type from an rvalue of type

Question

Problem :

Below is the wrong form:

int &z = 12;

Following is the correct form:

int y;

int &r = y;

Question:
Why is a first code wrong? What is a "meaning" of a below error?

“Invalid initialization of non-const reference of type from an rvalue of type”

Answer 1

C++03 3.10/1 says that: "Every expression is either the lvalue or the rvalue." It is very important to remember that the lvalueness versus the rvalueness is the property of expressions and not of the objects.

Lvalues name objects that persist beyond the single expression. For example, obj , *ptr , ptr[index] , and ++x are all of the lvalues.

Rvalues are the temporaries that evaporate at a end of the full-expression in which they live ("at a semicolon"). For example, 1729 , x + y , std::string("meow") , and x++ are all of the rvalues.

A address-of the operator requires that its "operand shall be the lvalue". if we could take a address of one of the expression then the expression is the lvalue, otherwise it is termed as the rvalue.

 &obj; //  it is valid

 &12;  //it is invalid

 OR

12 is the compile-time constant which can not be changed unlike a data referenced by the int&. What you can do is as below

const int& z = 12;

Answer 2

C++03 3.10/1 says: "Every expression is either an lvalue or an rvalue." It's important to remember that lvalueness versus rvalueness is a property of expressions, not of objects.

Lvalues name objects that persist beyond a single expression. For example, obj , *ptr , ptr[index] , and ++x are all lvalues.

Explanation:

Rvalues are temporaries that evaporate at the end of the full-expression in which they live ("at the semicolon"). For example, 1729 , x + y , std::string("meow") , and x++ are all rvalues.

The address-of operator requires that its "operand shall be an lvalue". if we could take the address of one expression, the expression is an lvalue, otherwise it's an rvalue.

&obj; //  valid
 &12;  //invalid

10 is a constant, so you can't pass a reference to it, simply because the whole concept of changing a constant is bizarre.

References were introduced to solve one of the thorny problems in C (and earlier C++), the fact that everything is passed by value and, if you want to have a change reflected back to the caller, you have to pass in a pointer and dereference that pointer within the function to get at the actual variable (for reading and writing to it).

This is something that would be seriously good to have in the next ISO C standard. While having to use pointers may give some of us a lot of rep on Stack Overflow, it's not doing the C programmers of the world much good :-)

The solution to your problem is simple. If you don't need to change the item in the function, just pass it normally:

int fun (int x) { ... }

10 is a constant, so you can't pass a reference to it, simply because the whole concept of changing a constant is bizarre.

References were introduced to solve one of the thorny problems in C (and earlier C++), the fact that everything is passed by value and, if you want to have a change reflected back to the caller, you have to pass in a pointer and dereference that pointer within the function to get at the actual variable (for reading and writing to it).

This is something that would be seriously good to have in the next ISO C standard. While having to use pointers may give some of us a lot of rep on Stack Overflow, it's not doing the C programmers of the world much good :-)

The solution to your problem is simple. If you don't need to change the item in the function, just pass it normally:

int fun (int x) { ... }

If you do need to change it, well, then you'll have to pass something that can be changed:

int xyzzy = 10;
cout << fun (xyzzy);