What are the differences between a pointer variable and a reference variable in C++?

Question

I know references are syntactic sugar, so code is easier to read and write.

But what is the difference between a pointer variable and a reference variable?

Answer 1

1. A pointer can be re-assigned:

   int x = 5; int y = 6; int *p; p = &x; p = &y; *p = 10; assert(x == 5); assert(y == 10); 

   A reference cannot be re-bound, and must be bound at initialization:

   int x = 5; int y = 6; int &q; // error int &r = x; 

2. A pointer variable has its own identity: a distinct, visible memory address that can be taken with the unary & operator and a certain amount of space that can be measured with the sizeof operator. Using those operators on a reference returns a value corresponding to whatever the reference is bound to; the reference’s own address and size are invisible. Since the reference assumes the identity of the original variable in this way, it is convenient to think of a reference as another name for the same variable.

   int x = 0; int &r = x; int *p = &x; int *p2 = &r;  assert(p == p2); // &x == &r assert(&p != &p2); 

3. You can have arbitrarily nested pointers to pointers offering extra levels of indirection. References only offer one level of indirection.

   int x = 0; int y = 0; int *p = &x; int *q = &y; int **pp = &p;  **pp = 2; pp = &q; // *pp is now q **pp = 4;  assert(y == 4); assert(x == 2); 

4. A pointer can be assigned nullptr, whereas a reference must be bound to an existing object. If you try hard enough, you can bind a reference to nullptr, but this is undefined and will not behave consistently.

   /* the code below is undefined; your compiler may optimise it  * differently, emit warnings, or outright refuse to compile it */  int &r = *static_cast<int *>(nullptr);  // prints "null" under GCC 10 std::cout     << (&r != nullptr         ? "not null" : "null")     << std::endl;  bool f(int &r) { return &r != nullptr; }  // prints "not null" under GCC 10 std::cout     << (f(*static_cast<int *>(nullptr))         ? "not null" : "null")     << std::endl; 

   You can, however, have a reference to a pointer whose value is nullptr.

5. Pointers can iterate over an array; you can use ++ to go to the next item that a pointer is pointing to, and + 4 to go to the 5th element. This is no matter what size the object is that the pointer points to.

6. A pointer needs to be dereferenced with * to access the memory location it points to, whereas a reference can be used directly. A pointer to a class/struct uses -> to access its members whereas a reference uses a ..

7. References cannot be put into an array, whereas pointers can be (Mentioned by user @litb)

8. Const references can be bound to temporaries. Pointers cannot (not without some indirection):

   const int &x = int(12); // legal C++ int *y = &int(12); // illegal to take the address of a temporary. 

   This makes const & more convenient to use in argument lists and so forth.

Answer 2

What's a C++ reference (for C programmers)

A reference can be thought of as a constant pointer (not to be confused with a pointer to a constant value!) with automatic indirection, ie the compiler will apply the * operator for you.

All references must be initialized with a non-null value or compilation will fail. It's neither possible to get the address of a reference - the address operator will return the address of the referenced value instead - nor is it possible to do arithmetics on references.

C programmers might dislike C++ references as it will no longer be obvious when indirection happens or if an argument gets passed by value or by pointer without looking at function signatures.

C++ programmers might dislike using pointers as they are considered unsafe - although references aren't really any safer than constant pointers except in the most trivial cases - lack the convenience of automatic indirection and carry a different semantic connotation.

Consider the following statement from the C++ FAQ:

Even though a reference is often implemented using an address in the underlying assembly language, please do not think of a reference as a funny looking pointer to an object. A reference is the object. It is not a pointer to the object, nor a copy of the object. It is the object.

But if a reference really were the object, how could there be dangling references? In unmanaged languages, it's impossible for references to be any 'safer' than pointers - there generally just isn't a way to reliably alias values across scope boundaries!

Why I consider C++ references useful

Coming from a C background, C++ references may look like a somewhat silly concept, but one should still use them instead of pointers where possible: Automatic indirection is convenient, and references become especially useful when dealing with RAII - but not because of any perceived safety advantage, but rather because they make writing idiomatic code less awkward.

RAII is one of the central concepts of C++, but it interacts non-trivially with copying semantics. Passing objects by reference avoids these issues as no copying is involved. If references were not present in the language, you'd have to use pointers instead, which are more cumbersome to use, thus violating the language design principle that the best-practice solution should be easier than the alternatives.