41

The following program

void display(const int& a)
{
    cout << a ;
}

will work if called with a literal like this

display(5);

but without the const it won't work.

So how can a const reference keep pointing to an R-Value (anonymous variable)?

cigien
  • 57,834
  • 11
  • 73
  • 112
AnotherOne
  • 854
  • 2
  • 8
  • 19

5 Answers5

43

For your final question:

how can a const reference keep pointing to an R-Value (anonymous variable)

Here is the answer. The C++ language says that a local const reference prolongs the lifetime of temporary values until the end of the containing scope, but saving you the cost of a copy-construction (i.e. if you were to use an local variable instead).

Tanz87
  • 1,111
  • 11
  • 10
  • This is a very nice link, but isn't it unnecessary in the OP's example? Whatever temporary value is constructed during a function call (in this case 5) will stay on stack for the whole duration of the callee, so you don't _have_ to extend its lifetime – ScumCoder Feb 06 '23 at 11:47
24

Think of any object as the box containing some value inside and the box may or may not have name tag, i.e. the box with name tag as variable and the box without name tag as literal. Whether name tag is there or not, we have the box.

Reference is the way that we add name tag to our box.

int a = 5;
int &b = a;

we have two name tags for our box (with value 5 inside).

const int &c = 5;

there you are, the box was just named.

The new name of the box that has never had a name before must be marked as const. Because the value inside the box can be changed through its name, which we do not want it to happen (not allowed to happen) to our literal box.

Sithideth Bouasavanh
  • 1,011
  • 1
  • 11
  • 20
6

It gets back to the definition of literal. A literal is a constant; e.g. the value of the number 5 will not change, ever, though a variable may change from being assigned the value of 5 to another value. Passing a literal by reference implies that the function may modify it, which is something you can't do to a literal, by definition, which is why the language requires that you modify it with const. I don't think C++ could modify literals even if it let you try, but it still enforces this convention to remind the programmer that a literal value cannot be modified.

cigien
  • 57,834
  • 11
  • 73
  • 112
Durendal
  • 61
  • 3
  • actually what I', asking about is how could a constant reference keep pointing to an anonymous variable that has expression scope , and thank's – AnotherOne Mar 19 '16 at 14:45
  • So you're wondering why the reference doesn't lose track of what it's referring to, since the literal's lifetime should expire after that expression? – Durendal Mar 19 '16 at 15:05
  • that's what I was wandering about – AnotherOne Mar 19 '16 at 18:25
  • _"I don't think C++ could modify literals even if it let you try"_ old FORTRAN compilers stored some literal values in memory, and because of a bug you could assign 1 to the literal 0 – ScumCoder Feb 06 '23 at 11:44
3

Because literals are constant. 1 cannot become 2, and "abd" cannot become "edf".

If C++ allowed you to take literals by non-const reference, then it would either:

  1. Have to allow literals to change their meaning dynamically, allowing you to make 1 become 2.
  2. Expect the programmer to take extra care to modify values only via those references which do not refer to literals, and invoke undefined behaviour if you get it wrong.

(1) would create chaos in your program, because x == 1 could mean "is x equal to 2" depending on the context, and (2) is impossible to achieve because how is void display(int& a) supposed to know if it receives a literal reference or not?

Since neither of these two options makes sense, literals can only be passed by const references.

Actually, the deprecated conversion from string literals to char* is a good example of why the rules make a lot of sense, although it's not a reference but a pointer. You are allowed to let a char* point to "abc", but an attempt to actually utilise the "modifiability" attribute of the char* and modify one of the char elements results in undefined behaviour. This makes the whole deprecated conversion both dangerous and useless (in non-legacy code).

You wouldn't want to have such troubles in all other parts of the language, would you?

Christian Hackl
  • 27,051
  • 3
  • 32
  • 62
  • actually what I', asking about is how could a constant reference keep pointing to an anonymous variable that has expression scope , and thank's – AnotherOne Mar 19 '16 at 14:48
2

An r-value is a temporary evanescent object, that can be read but is about to be destroyed. It is also a value that cannot stay on the left-hand side of an assignment (how could you make sense of assigning values to such a ghost?)

C++ has a very specific way to deal with this kind of entities. If you could pass an r-value by (non-const) reference, you could also be able to assign to it from inside the function. Therefore the rule that if r-values are to be passed by reference, this has to be a const reference.

This is not the whole truth though, because you have, indeed, r-value references (denoted with &&). So, you can, in the end, manipulate a temporary object, but you have to make an explicit statement that you really want to do so, using r-value references.

Emerald Weapon
  • 2,392
  • 18
  • 29