在C ++中延长临时值的生命周期

Question

const int &ra=3;

1. As I know, making ra const will extends the lifetime of the temporary r-value which is in this case 3. This is a little bit confusing, as I know ra should have the same address as r-value which is here 3, but 3 is not a real variable and it does not have a memory where it's stored. So how can this be possible?

2. what is the difference between:

    const int& ra=a; 

   and

    int& const ra=a; 

Answer 1

but 3 is not a real variable and it does not have a memory where it's stored. so how can this be possible ?

Actually a temporary object gets created out of the literal 3 , and then that temporary is bound to the const reference. That is how it becomes possible.

---

Now your next question: the difference between these two

const int& ra=a;
int& const ra=a;

is that the second statement is illegal.

Answer 2

1) Whether or not the compiler decides to actually store your number 3 is a detail subject to optimisation decisions. As far as the language is concerned, the temporary object lives as long as the reference. Practically, if you only need the value (not the object ), the object may never be stored at all, and instead the compiler may substitute the value directly whenever you use ra . Of course, if you take the address (via &ra ), then the compiler will make sure that an object is actually stored somewhere so that you can take its address. (It may still substitute the value directly elsewhere, rather than loading it from that address.)

2) The second version isn't valid C++. You can only say int const & x and const int & x , for the same reason that int const and const int denote the same type. The reference itself has no notion of constancy; it is always bound to the object with which it is initialized (ie you can't have a "naked" reference object int & x; ).

Answer 3

From my understanding, when you make a variable const, it's allocated a memory where it's stored, like any other variable. Depending on the compiler, if you place that const 3 in a function, it might allocate a temp 3 every time you call the function, or it might just reference a static value allocated when the program started. That 3 is a real variable in that it's data that's been stored somewhere, just like every other variable.

However, referencing that value outside of its scope is going to be a crapshoot as to whether or not it will work, and so you shouldn't use that as a way to "extend the life" of a variable. You might get lucky and have the const be allocated in a static place, and so you'll always get the value you want, even when you access it out of scope; but you might get unlucky, and end up grabbing data that's written over the temp value you wanted. The behavior is "undefined" - that means compilers decide how they want to do it, so there's no way you can count on. Instead, increase the scope of the variable by declaring it earlier, or allocating it on heap ( int* x = malloc(sizeof(int))//, etc. and passing its pointer around.