Click here to Skip to main content
15,881,803 members
Search within:


Articles / Programming Languages / C++
 
Article

An Insight to References in C++

Rate me:
Please Sign up or sign in to vote.
3.52/5 (46 votes)
18 Apr 2006CPOL4 min read 163.9K   37   73
How C++ Compiler handles References

Introduction

I choose to write about references in C++ because I feel most of the people have misconceptions about references. I got this feeling because I took many C++ interviews and I seldom get correct answers about references in C++.

What is meant by references in C++? A reference is generally thought of as an aliasing of the variable it refers to. I hate the definition of references being an alias of a variable in C++. In this article, I will try to explain that there is nothing known as aliasing in C++.

Background

Both in C and in C++, there are only two ways by which a variable can be accessed, passed, or retrieved. The two ways are: 

  1. Accessing/passing variable by value
  2. Accessing/Passing variable by address - In this case pointers will come into the picture

There is no 3rd way of accessing/passing variables. A reference variable is just another pointer variable which will take its own space in memory. The most important thing about the references is that it's a type of pointer which gets automatically dereferenced (by compiler). Hard to believe? Let's see....

A Sample C++ Code using References

Lets write a simple C++ code which will use references:

C++
#include <iostream.h>
int main()
{
    int i = 10;   // A simple integer variable
    int &j = i;   // A Reference to the variable i
    
    j++;   // Incrementing j will increment both i and j.

    // check by printing values of i and j
    cout<<  i  <<  j  <<endl; // should print 11 11

    // Now try to print the address of both variables i and j
    cout<<  &i  <<  &j  <<endl; 
    // surprisingly both print the same address and make us feel that they are
    // alias to the same memory location. 
    // In example below we will see what is the reality
    return 0;
}

References are nothing but constant pointers in C++. A statement int &i = j; will be converted by the compiler to int *const i = &j; i.e. References are nothing but constant pointers. They need initialization because constants must be initialized and since the pointer is constant, they can't point to anything else. Let's take the same example of references in C++ and this time we will use the syntax that the compiler uses when it sees references.

A Sample C++ Code using References (Compiler Generated Syntax)

C++
#include <iostream.h>
int main()
{
    int i = 10;   		// A simple integer variable
    int *const j = &i;   	// A Reference to the variable i
    
    (*j)++;   		// Incrementing j. Since reference variables are 
			// automatically dereferenced by compiler

    // check by printing values of i and j
    cout<<  i  <<  *j  <<endl; // should print 11 11
    // A * is appended before j because it used to be reference variable
    // and it should get automatically dereferenced.
    return 0;
}

You must be wondering why I skipped the printing of address from the above example. This needs some explanation. Since reference variables are automatically dereferenced, what will happen to a statement like cout << &j << endl;. The compiler will convert the statement into cout << &*j << endl; because the variable gets automatically dereferenced. Now &* cancels each other. They become meaningless and cout prints the value at j which is nothing but the address of i because of the statement int *const j = &i;.

So the statement cout << &i << &j << endl; becomes cout << &i << &*j << endl; which is similar to printing the address of i in both the cases. This is the reason behind the same address being displayed while we try to print normal variables as well as reference variables.

A Sample C++ Code using Reference Cascading

Here we will try to look at a complex scenario and see how references will work in cascading. Let's follow the code below:

C++
#include <iostream.h>
int main()
{
    int i = 10; // A Simple Integer variable
    int &j = i; // A Reference to the variable
    // Now we can also create a reference to reference variable. 
    int &k = j; // A reference to a reference variable
    // Similarly we can also create another reference to the reference variable k
    int &l = k; // A reference to a reference to a reference variable.

    // Now if we increment any one of them the effect will be visible on all the
    // variables.
    // First print original values
    // The print should be 10,10,10,10
    cout<<  i  <<  ","  <<  j  <<  ","  <<  k  <<  ","  <<  l  <<endl;
    // increment variable j
    j++; 
    // The print should be 11,11,11,11
    cout<<  i  <<  ","  <<  j  <<  ","  <<  k  <<  ","  <<  l  <<endl;
    // increment variable k
    k++;
    // The print should be 12,12,12,12
    cout<<  i  <<  ","  <<  j  <<  ","  <<  k  <<  ","  <<  l  <<endl;
    // increment variable l
    l++;
    // The print should be 13,13,13,13
    cout<<  i  <<  ","  <<  j  <<  ","  <<  k  <<  ","  <<  l  <<endl;
    return 0;
}

A sample C++ Code Using Reference Cascading (Compiler Generated Syntax)

Here we will see if we won't depend upon the compiler to generate constant pointers in place of reference and auto dereferencing the constant pointer, we can achieve the same results.

C++
#include <iostream.h>
int main()
{
    int i = 10;         // A Simple Integer variable
    int *const j = &i;     // A Reference to the variable
    // The variable j will hold the address of i

    // Now we can also create a reference to reference variable. 
    int *const k = &*j;     // A reference to a reference variable
    // The variable k will also hold the address of i because j 
    // is a reference variable and 
    // it gets auto dereferenced. After & and * cancels each other 
    // k will hold the value of
    // j which it nothing but address of i

    // Similarly we can also create another reference to the reference variable k
    int *const l = &*k;     // A reference to a reference to a reference variable.
    // The variable l will also hold address of i because k holds address of i after
    // & and * cancels each other.

    // so we have seen that all the reference variable will actually holds the same
    // variable address.

    // Now if we increment any one of them the effect will be visible on all the
    // variables.
    // First print original values. The reference variables will have * prefixed because 
    // these variables gets automatically dereferenced.

    // The print should be 10,10,10,10
    cout<<  i  <<  ","  <<  *j  <<  ","  <<  *k  <<  ","  <<  *l  <<endl;
    // increment variable j
    (*j)++; 
    // The print should be 11,11,11,11
    cout<<  i  <<  ","  <<  *j  <<  ","  <<  *k  <<  ","  <<  *l  <<endl;
    // increment variable k
    (*k)++;
    // The print should be 12,12,12,12
    cout<<  i  <<  ","  <<  *j  <<  ","  <<  *k  <<  ","  <<  *l  <<endl;
    // increment variable l
    (*l)++;
    // The print should be 13,13,13,13
    cout  <<  i  <<  ","  <<  *j  <<  ","  <<  *k  <<  ","  <<  *l  <<endl;
    return 0;
}

A Reference Takes its Own Space in Memory

We can see this by checking the size of the class which has only reference variables. The example below proofs that a C++ reference is not an alias and takes its own space into the memory.

C++
#include <iostream.h>

class Test
{
    int &i;   // int *const i;
    int &j;   // int *const j;
    int &k;   // int *const k; 
};

int main()
{    
    // This will print 12 i.e. size of 3 pointers
    cout<<  "size of class Test = "  <<   sizeof(class Test)  <<endl;
    return 0;
}

Conclusion

I hope that this article explains everything about C++ references. However I'd like to mention that C++ standard doesn't explain how reference behaviour should be implemented by the compiler. It's up to the compiler to decide, and most of the time it is implemented as a constant pointer.

Additional Notes to Support this Article

In the discussion forums for this article, people were having concerns that References are not constant pointers but aliases. I am writing one more example to support this fact. Look carefully at the example below:

C++
#include <iostream.h>

class A
{
public:
	virtual void print() { cout<<"A.."<<endl; }
};

class B : public A
{
public:
	virtual void print() { cout<<"B.."<<endl; }
};

class C : public B
{
public:
	virtual void print() { cout<<"C.."<<endl; }
};

int main()
{
	C c1;
	A &a1 = c1;
	a1.print(); // prints C

 	A a2 = c1;
	a2.print(); // prints A
	return 0;
}

The example using references supports the virtual mechanism, i.e. looking into the virtual pointer to get the handle to correct function pointer. The interesting thing here is how the virtual mechanism is supported by the static type which is simply an alias. Virtual mechanism is supported by dynamic information which will come into the picture only when a pointer is involved. I hope this will clarify most of the doubts.

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)


Written By
itsdkg
Architect
India India
A programmer by heart since 1998. Written code in C++, Java, JavaScript, Python & Ruby, Worked on Stack Development to Web Development. Data Specialist with SQL and NoSQL DBs

Comments and Discussions

 
FirstPrevNext
GeneralRe: Confusing article Pin
Matthias Becker2-Apr-06 8:45
Matthias Becker2-Apr-06 8:45 
GeneralRe: Confusing article Pin
itsdkg5-Apr-06 18:56
itsdkg5-Apr-06 18:56 
GeneralRe: Confusing article Pin
jefito12-Apr-06 6:03
jefito12-Apr-06 6:03 
GeneralRe: Confusing article Pin
itsdkg18-Apr-06 19:34
itsdkg18-Apr-06 19:34 
GeneralRe: Confusing article Pin
Rainer Schuster18-Apr-06 21:14
Rainer Schuster18-Apr-06 21:14 
GeneralRe: Confusing article Pin
Iftahh19-Apr-06 2:24
Iftahh19-Apr-06 2:24 
GeneralRe: Confusing article Pin
Ilya Lipovsky28-Apr-06 11:54
Ilya Lipovsky28-Apr-06 11:54 
GeneralRe: Confusing article Pin
jefito1-May-06 7:32
jefito1-May-06 7:32 
Ilya Lipovsky wrote:
The problem, however, is that whatever the standard says is not the way some very popular compilers implement the concept of references.


Really? That's a bold claim. Which compilers? How do they differ?

There is a difference between "automatically dereferenced const pointer" and "alias."

In the first case the compiler is obligated to treat all reference variable declarations as const pointer declarations, and automatically dereference all further instances thereof, before proceeding with further compilation and potential optimizations.


Really? Where is that statement mandated? What section of the Standard?

It should generate the same code that would be generated, if the user were to replace all uses of reference variables by dereferenced const pointer equivalents (with their initializations being the exception: not dereferenced, but having "=" replaced with "= &").


And again, where is this claim from?

In the latter case, however, the compiler has to preprocess all instances of reference variables and resolve them into the name of the variable they reference. Basically, the same as #define'ing, only performed at compile-time, instead of preprocess-time. The code generated in this case is essentially the same as running the C preprocessor appropriately.


What are your sources for this information?

Gatik said that the first situation holds true, not the second one.


If Gatik indeed thinks that an alias is another name for an object (not a variable, as you seem to think), a term that he either won't or can't define for his readers, Gatik is incorrect in his claim, something that I showed with a concrete example. If by 'alias' he means something else, his obligation is to define it.

After initially disagreeing with him (I thought it was the second case), I performed some tests with gcc on PowerPC, and had to retract.


Neither you nor Gatik seem to understand the nature of proof. It's as if Gatik were claiming that all humans are left-handed. All of the humans that he knows are left-handed, and you found a human who is left-handed, there for you think that that's a proof. Even though I can point to a human who is not left-handed, you and he continue claiming that you have proved the assertion. You are both incorrect.

Ilya Lipovsky wrote:
Again, I don't know whether Visual C++ implements reference variables with automatically dereferenced const pointers or aliases, but in gcc world the first holds true.


You don't seem to understand the distinction between what the Standard requires and what it allows. Nearly everyone agrees references behave in at least some respects like a const pointer, but there is no guarantee that it is identical, nor that it be implemented using pointers. I am guessing that that holds true with gcc; I've already shown that is does with VC++. All you have shown is that gcc implements them like that in some cases, but that does not in any way constitute a proof. Have you examined the specifications and source code for gcc to validate your claim? I hope that I don't have to rustle up a copy of gcc to find a counterexample in there as well.

I still look forward to compilation results on Visual C++. Jeff indeed provided some, but I want to make sure that optimizations were turned off. Why it matters? Even with Gatik being right, the compiler *may* be smart enough to "realize" during a certain stage of compilation (like the SSA stage of gcc) that all reference variable names can be optimized away and replaced by the name of the original variable.


You seem confused on the topic of optimization. Optimization is in the realm of implementation -- there's no requirement that a compiler provide certain optimizations, nor is there a requirement that a compiler not provide certain optimizations by default. The compiler is largely free to do as it sees fit, so long as the meaning of the program is preserved. It can implement variables in registers, remove unused variables, inline functions, move computations around, and so on. Whether it does things by default, or as a result of compiler settings is irrelevant -- if the meaning of the program is preserved, it's all fair game --- it's implementation-dependent. Whether I had VC++ optimisations turned on or off does not matter -- the program was compiled into correct code, without the use of any memory space for the reference.

In the end, all of this comes down to the simple statement that "a reference is another name for an object". It's a simple notion, and is supported by the Standard and other reference literature, as well as existing compilers, even gcc. There's no requirement that a reference take up memory space, as Gatik claims. This is false, as examples have shown.

regards,

Jeff
GeneralRe: Confusing article Pin
Ilya Lipovsky1-May-06 13:13
Ilya Lipovsky1-May-06 13:13 
GeneralRe: Confusing article Pin
jefito2-May-06 3:26
jefito2-May-06 3:26 
GeneralRe: Confusing article Pin
Ilya Lipovsky2-May-06 6:15
Ilya Lipovsky2-May-06 6:15 
GeneralRe: Confusing article Pin
jefito2-May-06 8:00
jefito2-May-06 8:00 
GeneralRe: Confusing article Pin
Ilya Lipovsky2-May-06 10:10
Ilya Lipovsky2-May-06 10:10 
GeneralRe: Confusing article Pin
jefito2-May-06 12:17
jefito2-May-06 12:17 
GeneralRe: Confusing article Pin
Ilya Lipovsky2-May-06 13:09
Ilya Lipovsky2-May-06 13:09 
GeneralRe: Confusing article Pin
jefito3-May-06 11:21
jefito3-May-06 11:21 
GeneralRe: Confusing article Pin
Ilya Lipovsky2-May-06 10:39
Ilya Lipovsky2-May-06 10:39 
GeneralRe: Confusing article Pin
jefito19-Apr-06 9:22
jefito19-Apr-06 9:22 
GeneralRe: Confusing article Pin
itsdkg12-May-06 3:40
itsdkg12-May-06 3:40 
GeneralRe: Confusing article Pin
jefito13-May-06 17:18
jefito13-May-06 17:18 
GeneralRe: Confusing article Pin
Androne19-Apr-06 5:09
Androne19-Apr-06 5:09 
GeneralRe: Confusing article Pin
Kamal Barshevich8-Apr-21 8:16
Kamal Barshevich8-Apr-21 8:16 
GeneralCertain Inaccuracies Found Pin
Ilya Lipovsky14-Mar-06 8:46
Ilya Lipovsky14-Mar-06 8:46 
GeneralRe: Certain Inaccuracies Found Pin
Paulius Maruka14-Mar-06 12:41
Paulius Maruka14-Mar-06 12:41 
GeneralRe: Certain Inaccuracies Found Pin
Ilya Lipovsky14-Mar-06 15:15
Ilya Lipovsky14-Mar-06 15:15 
Last Visit: 31-Dec-99 18:00     Last Update: 19-Apr-24 12:31Refreshᐊ Prev123 Next ᐅ

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Praise Praise    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

Permalink
Advertise
Privacy
Cookies
Terms of Use
Layout: fixed | fluid

Posted 8 Mar 2006

Article Copyright 2006 by itsdkg
Everything else Copyright © CodeProject, 1999-2024

Web02 2.8:2024-04-02:1