Difference between const. pointer and reference?

Question

Hi

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 it's 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 (e.g. int* const ptr), not a pointer to const (e.g. 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

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 4

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 );
}