Navigation Bar

13 October 2011

[C++] - Reference vs Pointers

Introduction - Reference and Pointers

A pointer is a notation that says it points to something. In C++ or C that something is known as an address. The next question, what is address? Hey, Rachel! Where do you stay? She will give her address to her new friend so that he can locate her living place. The context is same in c++ also. Every value stored by your program will occupy some memory location.

Here we will see some basics of what are pointer variable, reference variable, and a normal variable.

A simple pointer and reference to a variable

A variable is declared as follows:
int                    x;

X is the variable name
int specified the type of data that can be stored in x.

Let us assume that the variable shown above is declared in the void main of the program. The variable scope is inside the main and we know that the variable occupies some memory in the call stack of main. Now the x is a naming given to the location in the stack that is allocated by the void main function. Using the assignment operator and the variable x the location is accessed. So the address involved is hidden behind the scene and all you know is variable name x and internally is has an association to a location in the stack memory of the main function.

Now have a look at the variable declaration below:
int&      refto_x  = x;

refto_x is reference variable and that references the variable x. Int& specifies the reference notation and reference to what data type.

The reference variable should be initialized when it is declared. See… in our example statement we declared a reference variable refto_x and initialized it with the assignment = x. What does that say? Well. X is a naming notation used internally to read or write from a specific memory location in a stack (When x is not a global variable and declared inside some function) and simply it is a variable declared already. And refto_x is a naming notation for the naming x. That means refto_x is simply one more naming given to the location represented by the variable x.

Now look at the statement below:
int * pointerto_x = &x;

int * - Represents pointer to an integer
pointerto_x – A variable name given to the pointer variable
&x – Address of the variable x.

In the above declaration, a pointer variable pointerto_x is declared and at the same time initialized to have the address of the variable x. Note that in the above statement unlike reference it is not just one more name to the location represented by x. It has it own location represented by a variable pointerto_x and that location can store address location and when it access that location it treats that address location to read or write integer sized data.

Basic explanation for reference and pointers

Let us explore the pointer, reference and a normal variable with an example. Consider the below four statements:
int _tmain(int argc, _TCHAR* argv[])
//Declare an integer variable, then have a pointer and reference to it
int                     x;
int&       refto_x  = x;
int * pointerto_x = &x;
x = 10;

First, we declared an integer variable x and then had a reference to it in the variable refto_x. Then the pointer variable pointerto_x is declared and initialized to hold the address of the variable x. Finally, we assigned value 10 to the variable x. Have a look at the below picture:

The above three variable creation and assignment of value 10 is depicted as above. First, to store the value 10 we need some bits in memory. Second as the variable x is declared inside the _tmain () function and value 10 is assigned to the variable x, memory in the stack holds the value 10.  To read or write from this memory location we use the variable x.

p = x + 15;
In the above statement, the value in the stack memory identified by the variable x is read then assigned to variable p after summing it with a value 15.

x = p - 10;
In the above statement the value in p is decremented by 10 then written to the memory location identified by the variable x.

So, according to x, the read or write operation defined by the variable x and it position in relation to the assignment operator =. C++ developers call the variable name and its corresponding memory location as naming association.

Now explaining the reference is easy. In our example statements above, refto_x is just one more naming association to the same stack memory. That means x and refto_x both corresponds to the same memory in the stack. What about pointerto_x? It stores the address of the memory location for x or refto_x.

The above four statements can further explained in detail by using the below depiction:

1.      FE100B12: Memory address of stack that holds value 10
2.      FF820CD7: Again, memory address of stack that holds address of some other memory in stack (32 bit address or 64 bit address)
3.      Variable x is associated to the memory location FE100B12
4.      Variable refto_x is also associated to the memory location FE100B12
5.      Variable pointerto_x is associated to the memory location FF820CD7

Note that x, refto_x and pointerto_x all declared inside the main () and have an association to the stack memory. I will talk about heap later and that is different.

The value in the location is shown above. If you just read the content of the pointer variable pointerto_x, then you will get memory location of the variable. To read the content, you should de-reference the pointer.

int m = * pointerto_x;

In the above statement we specifed that we do not want the content of pointerto_x (Which is an address), But we want the actual value in the address which stored in the pointerto_x.

Code and Example

Below is the complete example and output:

#include "stdafx.h"
#include <conio.h>

int _tmain(int argc, _TCHAR* argv[])

            //Declare an integer variable, then have a pointer and reference to it
            int                     x;
            int&       refto_x  = x;
            int * pointerto_x = &x;

            //Assing a value to x and print the value in it using value, refernce and pointer
            x = 10;
            printf("X=%d\n", x);
            printf("Value in x through refto_x=%d\n", refto_x);
            printf("Value in x tnrough pointerto_x=%d\n", *pointerto_x );

            //Now check the address of all the three variables
            printf("********* Adress of Value, reference, pointer variables *********\n");
            printf("Address of x=%d\n", &x);
            printf("Address of refto_x=%d\n", &refto_x);
            printf("Address of pointerto_x=%d\n", &pointerto_x );
            //Special case
            printf("Then what is stored in pointerto_x? It is %d, address of x", pointerto_x);

            return 0;