Difference between const. pointer and reference?

Question

What is the difference between a constant pointer and a reference?

Constant pointer as the name implies can not be bound again. Same is the case with the reference.

I wonder in what sort of scenarios would one be preferred over the other. How different is their C++ standard and their implementations?

cheers

Answer 1

There are 3 types of const pointers:

//Data that p points to cannot be changed from p
const char* p = szBuffer;

//p cannot point to something different.  
char* const p = szBuffer;

//Both of the above restrictions apply on p
const char* const p = szBuffer;

Method #2 above is most similar to a reference.

There are key differences between references and all of the 3 types of const pointers above:

• Const pointers can be NULL.

• A reference does not have its own address whereas a pointer does.
  The address of a reference is the actual object's address.

• A pointer has its own address and it holds as its value the address of the value it points to.

• See my answer here for much more differences between references and pointers .

Answer 2

I assume that you mean a const-valued pointer (eg int* const ptr), not a pointer to const (eg int const* ptr).

• Not initializing a reference is a compile error (avoids the problem of uninitialized pointers)
• A pointer may also point to an array, or it can be NULL, where a reference always refers to exactly one object.
• The syntax is very different

Answer 3

When you should use each:

reference : Use these by default. It is very common for people to dereference NULL pointers. You eliminate that risk with a reference.

const pointer : When you want a reference, but can't make one. For example, you are writing a driver, and you'd like a pointer to the beginning of a memory map. A reference doesn't make as much sense in that case. Also, if you need an array of the things, a reference won't work (though an array of simple classes with reference members will).

In the next example, a const pointer checks an error that a reference can't check:

int addFour( int* register ){
  if(isNull(arg)){
    throw NullPointerException();
  }  

  // some stuff
  *register += 4;

  return register;
}

// This could be any function that does pointer math.
bool isNull(const int* ptr){
  return( NULL == ptr );
}

Answer 4

Almost all points have been covered by other answers, except this important one : It is possible to do arithmetics on pointers, but not on reference. Eg

int a[3] = {39, 18, 97};
int * const b = a;
int c = *(b+1);  // sets c = 18

Answer 5

Some differences:

A const pointer can point to NULL.

A const point can point to an array of objects.

A const pointer can be bound again by casting away the constness.

Answer 6

We are making smart pointer and our aim is to access member of class/structure using any of this T& (reference) or T* (pointer) with flexibility.

for T* operator-> ():

T* operator-> ()
{
  return pData;
}
arrow operator (->) is a shorthand for (*p) and hence we return *pData which is of   type T*. 
here we are Overloding arrow operator so that members of T can be accessed like a pointer.

for T& operator* ():

T& operator* ()
{
  return *pData;
}
    * is "value at address" operator, here we are Overloding * (pointer) operator so 
    that members of T can be accessed like we access variable through a reference.

We can change the behavior of the operator with operator overloading but its not recommended. overloaded operator behavior should be as close as its basic functionality.