> ## Content Index
> Fetch the complete content index at: https://developerinsider.co/llms.txt
> Use this file to discover other available public pages before exploring further.

# What are the differences between a pointer variable and a reference variable?
- URL: https://developerinsider.co/what-are-the-differences-between-a-pointer-variable-and-a-reference-variable/
- Published: 2016-05-10T18:05:52.000Z
- Updated: 2018-03-29T17:00:50.000Z
- Author: Vineet Choudhary
- Tags: Primary, C Programming, Interview

- 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, and must be assigned at initialization:  
```  
  int x = 5;  
  int y = 6;  
  int &r = x;  
```
- A pointer has its own memory address and size on the stack (4 bytes on x86), whereas a reference shares the same memory address (with the original variable) but also takes up some space on the stack. Since a reference has the same address as the original variable itself, it is safe to think of a reference as another name for the same variable. Note: What a pointer points to can be on the stack or heap. Ditto a reference. My claim in this statement is not that a pointer must point to the stack. A pointer is just a variable that holds a memory address. This variable is on the stack. Since a reference has its own space on the stack, and since the address is the same as the variable it references. More on stack vs heap. This implies that there is a real address of a reference that the compiler will not tell you.  
```  
  int x = 0;  
  int &r = x;  
  int *p = &x;  
  int *p2 = &r;  
  assert(p == p2);  
```
- You can have pointers to pointers to pointers offering extra levels of indirection. Whereas references only offer one level of indirection.  
```  
  int x = 0;  
  int y = 0;  
  int *p = &x;  
  int *q = &y;  
  int **pp = &p;  
  pp = &q;//*pp = q
  **pp = 4;  
  assert(y == 4);  
  assert(x == 0);  
```
- Pointer can be assigned NULL directly, whereas reference cannot. If you try hard enough, and you know how, you can make the address of a reference NULL. Likewise, if you try hard enough you can have a reference to a pointer, and then that reference can contain NULL.  
```  
  int *p = NULL;  
  int &r = NULL; <--- compiling error  
```
- 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.
- 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 it's members whereas a reference uses a ..
- A pointer is a variable that holds a memory address. Regardless of how a reference is implemented, a reference has the same memory address as the item it references.
- References cannot be stuffed into an array, whereas pointers can be.
- 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 dereference a temporary.  
```

This makes const & safer for use in argument lists and so forth.

[Click here to learn more about C and C++](https://developerinsider.co/c-and-cpp-insider)