Memory allocation for references

Question

Read a lot of differences between pointers & references.

Here is a brief description of what i learned.

1. Memory is allocated when a pointer is defined. A reference however, is a name alias & hence no memory is allocated for it(Is it correct?).

2. Reference is bound to be initialized at the time of definition because, a reference is implemented with a constant pointer & hence cannot be made to point to the other object. A pointer however, is not necessary to be initialized at the time of definition & hence can also be changed to point to some other object.

3. A reference automatically gets de-referenced. When you write cout << p; It is automatically de-referenced by the compiler & treated as cout << *p; by the compiler.

Here, p is the reference.

1. A reference to a reference is not possible.Whenever, you declare a reference to a reference, its actually the reference to the same variable. e.g.

   int i;    
   int &r1=i;    
   int &r2=r1; <-------------------2
   

Compiler interprets the statement 2 as:
int &r2=(*r1)
and (*r1) is nothing but the variable i itself.

A pointer to a pointer is however possible.

5. Array of pointer is possible while array of references is not possible(Why?).

6. Address of pointer is possible. Address of reference is not possible. It gives of the address of the variable.

7. There are situations where you are bound to use references.You cannot use pointers there. Consider the below example:

A a=b+c;

Where a,b,c are objects of class A. The operator '+' is overloaded as follows:

const A& operator+(const A& o)
{
     return A(i+o.i);
}

See sample code here: http://ideone.com/Q0pE1

Here the reference in the argument list is used to save the memory footprints.
You cannot use pointer in the argument list as you are bound to pass the address of object in the operator function.
A a=&b + &c;
However, if pointer is used in the parameter list, then we will end up adding the addresses rather than object itself.

I want to know that is there any other point that i am missing?

When should one go for pointer & when for reference?

Answer 1

Memory is allocated when a pointer is defined. A reference however, is a name alias & hence no memory is allocated for it

What do you mean by "memory is allocated?" If you mean a heap allocation, as with new or malloc or whatever, no:

int val = 5;
int *pVal = &val; //No dynamic memory allocation.

A pointer has a size, in the same way that int has a size. But that's different from an "allocation".

Reference is bound to be initialized at the time of definition because, a reference is implemented with a constant pointer & hence cannot be made to point to the other object.

No, a reference is bound at initialization time because that's how references work. They are references to objects. The language states that it is impossible for them to not be bound, and it is impossible for their binding to change later. Therefore, it is necessary that references are bound when they are initialized.

How a compiler implements references is entirely irrelevant.

A reference automatically gets de-referenced.

No. There is nothing to de-reference. A reference is merely another name for an already existing object. That's all.

Array of pointer is possible while array of references is not possible(Why?).

Because a reference has to be bound when it is initialized. And it's not possible to give each member of an array a separate object to be bound to. Thus, you would need some step between the creation of the array and the binding of the reference. Which is not allowed.

Address of pointer is possible. Address of reference is not possible. It gives of the address of the variable.

A reference is another name for an already existing object. You can't get the address of a name; you can only get the address of an object.

There are situations where you are bound to use references.

There's nothing stopping you from overloading operator+ for pointers to the types:

A operator+(const A *lhs, const A *rhs) {...}

Of course, this is a non-member function.

Oh, and as a bonus:

const A& operator+(const A& o)
{
     return A(i+o.i);
}

This is broken. You're returning a const& to a temporary you create. You should be returning it by value.