How references are internally stored in c++?

Question

I was just wondering, how references are internally stored? I felt that an understanding deep down that level will make me understand the concept pointer vs reference better and making decision choices.

I suspect that it basically works same as pointers but the compiler takes care of handling pointers. Please advise.

Answer 1

There's no requirement that a reference be "stored" in any way at all. As far as the language is concerned, a reference is just an alias of some existing object, and that's all that any compiler must provide.

It's entirely possible that there's no need to store anything at all if the reference is just a short-hand for some other object that's already in scope, or if a function with a reference argument gets inlined.

In situations where the reference needs to be made manifest (e.g. when calling a function in a different translation unit), you can practically implement a T & x as a T * const and treat every occurrence of x as implicitly dereferencing that pointer. Even on a higher level you can think of T & x = y; and T * const p = &y; (and correspondingly of x and *p) as essentially equivalent, so this would be an obvious way to implement references.

But of course there's no requirement, and any implementation is free to do whatever it wants.

Answer 2

References are just aliases internally the compiler treats them same as pointers.

But for the user from usage perspective there are several subtle differences.

Some of the major differences are:

• Pointers can be NULL while references cannot.There is nothing called as NULL reference.
• A const reference extends the lifetime of a temporary bound to it. There's no equivalent with pointers.

In addition, references have some things in common with const pointers (not a pointer to const):

• References must be initialized at time of creation.
• A reference is permanently bound to a single storage location, and cannot later be rebound.

When you know you have something(an object) to refer to and you'll never want to refer to anything else use a Reference else use pointers.

Answer 3

Sorry for using assembly to explain this but I think this is the best way to understand how references are implemented by compilers.

#include <iostream>

using namespace std;

int main()
{
    int i = 10;
    int *ptrToI = &i;
    int &refToI = i;

    cout << "i = " << i << "\n";
    cout << "&i = " << &i << "\n";

    cout << "ptrToI = " << ptrToI << "\n";
    cout << "*ptrToI = " << *ptrToI << "\n";
    cout << "&ptrToI = " << &ptrToI << "\n";

    cout << "refToNum = " << refToI << "\n";
    //cout << "*refToNum = " << *refToI << "\n";
    cout << "&refToNum = " << &refToI << "\n";

    return 0;
}

Output of this code is like this

i = 10
&i = 0xbf9e52f8
ptrToI = 0xbf9e52f8
*ptrToI = 10
&ptrToI = 0xbf9e52f4
refToNum = 10
&refToNum = 0xbf9e52f8

Lets look at the disassembly(I used GDB for this. 8,9 and 10 here are line numbers of code)

8           int i = 10;
0x08048698 <main()+18>: movl   $0xa,-0x10(%ebp)

Here $0xa is the 10(decimal) that we are assigning to i. -0x10(%ebp) here means content of ebp register –16(decimal). -0x10(%ebp) points to the address of i on stack.

9           int *ptrToI = &i;
0x0804869f <main()+25>: lea    -0x10(%ebp),%eax
0x080486a2 <main()+28>: mov    %eax,-0x14(%ebp)

Assign address of i to ptrToI. ptrToI is again on stack located at address -0x14(%ebp), that is ebp – 20(decimal).

10          int &refToI = i;
0x080486a5 <main()+31>: lea    -0x10(%ebp),%eax
0x080486a8 <main()+34>: mov    %eax,-0xc(%ebp)

Now here is the catch! Compare disassembly of line 9 and 10 and you will observer that ,-0x14(%ebp) is replaced by -0xc(%ebp) in line number 10. -0xc(%ebp) is the address of refToNum. It is allocated on stack. But you will never be able to get this address from you code because you are not required to know the address.

So; a reference does occupy memory. In this case it is the stack memory since we have allocated it as a local variable. How much memory does it occupy? As much a pointer occupies.

Now lets see how we access the reference and pointers. For simplicity I have shown only part of the assembly snippet

16          cout << "*ptrToI = " << *ptrToI << "\n";
0x08048746 <main()+192>:        mov    -0x14(%ebp),%eax
0x08048749 <main()+195>:        mov    (%eax),%ebx
19          cout << "refToNum = " << refToI << "\n";
0x080487b0 <main()+298>:        mov    -0xc(%ebp),%eax
0x080487b3 <main()+301>:        mov    (%eax),%ebx

Now compare the above two lines, you will see striking similarity. -0xc(%ebp) is the actual address of refToI which is never accessible to you. In simple terms, if you think of reference as a normal pointer, then accessing a reference is like fetching the value at address pointed to by the reference. Which means the below two lines of code will give you the same result

cout << "Value if i = " << *ptrToI << "\n";
cout << " Value if i = " << refToI << "\n";

Now compare this

15          cout << "ptrToI = " << ptrToI << "\n";
0x08048713 <main()+141>:        mov    -0x14(%ebp),%ebx
21          cout << "&refToNum = " << &refToI << "\n";
0x080487fb <main()+373>:        mov    -0xc(%ebp),%eax

I guess you are able to spot what is happening here. If you ask for &refToI, the contents of -0xc(%ebp) address location are returned and -0xc(%ebp) is where refToi resides and its contents are nothing but address of i.

One last thing, Why is this line commented?

//cout << "*refToNum = " << *refToI << "\n";

Because *refToI is not permitted and it will give you a compile time error.