How an alias for a variable works in C++

Question

As per my knowledge for int a; compiler will allocate a memory segment in stack, for int *p; also compiler will allocate a memory segment in stack but here p can only point to an address of integer variable.

In C++ we have a concept called alias (aka 'reference') like int &x=a; that means x will start working like a.

My question is whether the compiler allocates any separate memory segment for x also or compiler will treat x as a only; I mean will the compiler assign same address for both.

I'm not well-versed in the deeper bits of C++, but since you can have a const reference to a non-const variable, I *think* that would imply the variable and its reference get two different addresses. — cf-, Mar 01 '14 at 05:49
@computerfreaker, You'd still be able to use the same variable and enforce not modifying it separately. You could, however, consider a const reference to a temporary. — chris, Mar 01 '14 at 05:51
The standard makes no warrants on *how* compilers carry out the dictate of references; only the rules they must comply with in the behavior that results. There are *plenty* of posts that dissect the differences between pointers and references, [such as this one](http://stackoverflow.com/questions/57483/what-are-the-differences-between-pointer-variable-and-reference-variable-in-c), which is putting it mildly... involved. — WhozCraig, Mar 01 '14 at 06:17
Thanks @WhozCraig, i got so many other points by the post referred by you. — rajenpandit, Mar 01 '14 at 06:37
I did some research on my question, and i got some conclusion, find my post below. — rajenpandit, Mar 01 '14 at 06:43
Note that what you refer to as an "alias" is usually called a "reference" in C++. — chwarr, Mar 01 '14 at 08:10

score 3 · Answer 1 · answered Mar 01 '14 at 06:31

I was doing some research on my question, I got answer but it surprised me.

alias.cpp

int main()
{
        int a=5;
        int &x=a;
        int y=a+x;
}

A part of assembly code generated by using g++ -S alias.cpp

alisa.s

subl    $16, %esp
movl    $5, -12(%ebp)        //moving 5 to a
leal    -12(%ebp), %eax      // loading address of a to eax register
movl    %eax, -4(%ebp)       // moving address of a to -4(%ebp) this for x
movl    -4(%ebp), %eax       // moving the value of x that is address of a to eax
movl    (%eax), %edx         // moving the value of the address pointed by eax to edx
movl    -12(%ebp), %eax      // moving the value of a to eax
addl    %edx, %eax           // adding edx and eax

Another file alias2.cpp, here i am using pointer instead of alias.

int main()
{
        int a=5;
        int *x=&a;
        int y=a+*x;
}

the corresponding assembly code, alias2.s

subl    $16, %esp
movl    $5, -12(%ebp)
leal    -12(%ebp), %eax
movl    %eax, -4(%ebp)
movl    -4(%ebp), %eax
movl    (%eax), %edx
movl    -12(%ebp), %eax
addl    %edx, %eax

As we can see the both assembly files generated by two different code blocks are same. that means internally compiler is using the reference variable same as pointer variable, the only difference is the way of managing/writing the code.

Thanks for posting these details. This demonstrates a good way to check what the _specific version_ of the _specific compiler_ you are using with the _specific compiler settings_ you used to compile this _specific code_. Sometimes, that is all you care about. Sometimes, you care about the more general cases. If I had to guess, I'd say that this is non-optimized code. Try turning on optimizations and see if anything changes. — chwarr, Mar 01 '14 at 08:06

score 2 · Answer 2 · answered Mar 01 '14 at 05:51

2

Consider this

void foo(int& a) {
  a = 1;
}

int n = 0;
foo(n);

In order foo to work properly it shall receive address of passed variable. So essentially reference is a pointer to some memory location but with special treatment.

answered Mar 01 '14 at 05:51

c-smile

26,734
7
59
86

IIRC, the C++ standard says nothing about how references are to be implemented. In this example, if foo happened to be inlined, I'd expect that `n` and `a` could be treated as different names for the same thing. Say `n` is stored in `reg2`. I'd expect the inlined code of `foo` to just use `reg2` directly. Granted, many compilers do use a pointer-based implementation most of the time. This answer could be improved by pointing out these details. It's C++; the devil is always in the details. :-) – chwarr Mar 01 '14 at 08:08

score 0 · Answer 3 · answered Mar 01 '14 at 15:04

A reference is nothing more or less than a pointer in disguise. It is basically a C++ way of omitting adding the dereference operators when dereferencing a pointer.

From a language lawyer perspective, references may not be the same a pointers, but for all practical purposes, they are. Take for instance the assertion that references cannot be null, this is one of the arguments that people have used to advocate the use of references over pointers. However, while the language definition may disallow this, it is very easy to produce a null reference:

int& toReference(int* a) {
    return *a;
}

What happens when you pass a null pointer to toReference()? It will return a null reference. It won't technically dereference the pointer, because toReference() has no interest in the value behind the pointer. To avoid returning a null reference, the compiler would have to specifically insert code to check whether the pointer is null, and abort the program, which would be a waste of CPU time. You get the segfault the moment you try to access the data behind the returned reference, no sooner.

Now, should you use references in your code?
As I said above references are pointers in disguise, and that disguise can be harmful. For instance, if you see a call like the following in C, you can be certain that bar is not modified:

foo(bar);

In C++ you cannot be certain until you have checked whether the function definition contains a &. This is bad. Even worse: imagine you are using a function declared like this:

void foo(int a);

Now, if someone decided, he needed a to be an in/out parameter, and changed the definition into

void foo(int& a);

there would be absolutely no warning that the call foo(bar) would now silently modify the value of bar, i. e. the developer of foo() can break essential assumptions in unrelated places. The only way to avoid such nasty surprises, is to ban the use of non-const references from function arguments. You may use const-references when you want to stick to pass by value semantics and want to avoid the overhead of copying, but use pointers if you intent to modify.

How an alias for a variable works in C++

3 Answers3