What is the difference between `int *` and `int &`?

What is the difference between int *and int &?

They are different types. The first ( int *) is a pointer to an integer. The second ( int &) is an integer reference.

Pointer.

Pointers point to objects, their value is a memory address. For practical purposes, they would be a data type that can only point to other objects; as an analogy they would be a postal code (which points to an urban area) or a vehicle registration (points to a vehicle) or a passport number (points to a person).

Lifecycle.

A pointer to a type tipo *can point to more than one object of type tipoin its lifecycle, and can even point to no object at all or point to non-existent objects:

int *puntero = 0; // El puntero no apunta a nada.
{
    int valor = 0;
    puntero = &valor; // Apunta al objeto 'valor'.
}
// Aqui, 'puntero' sigue apuntando a 'valor' aunque dicho objeto ya no exista!
puntero = new int; // 'puntero' puede gestionar memoria dinamica!

Pointers are the only mechanism in C and C++ for managing dynamic memory; the operator newgenerates pointers on being called and transformation from array to pointer and vice versa is common practice.

Modification of the targeted object.

With a pointer you can point to virtually any part of memory, which is why pointers are considered dangerous as well as useful; this flexibility of pointers can allow memory that does not belong to the running program to be examined or modified (for analysis or hacking ) which can cause program crashes.

Operations.

1. Arithmetic : Arithmetic operations can be performed with pointers: by adding a value to a pointer we obtain a pointer pointing to a memory area displaced from the original pointer as many bytes as the size of the pointed value:

   char *puntero_char = 0;
   int *puntero_int = 0;
   
   puntero_char = puntero_char + 1;
   puntero_int = puntero_int - 1;
   

   By adding 1 to puntero_char, we will make the pointer point to the memory area 1 byte later than the area it originally pointed to (on systems that charoccupies one byte), subtracting 1 to will puntero_intmake the pointer point to the memory area 4 bytes earlier to the zone it originally pointed to (on systems that inttake up 4 bytes, or 32 bits). In both cases we will be pointing to memory that we should not be able to read or write, since both pointers were initialized to 0and the operating system usually prohibits access to the memory address 0(and various values ​​close to 0).

2. Address of : If we use the get-address operator on a pointer, we will add another level of pointer to the pointer, that is: the address of a pointer has type pointer to pointer, and the type of the address of the previous one would be pointer to pointer to pointer (and so on to infinity):

   int valor = 0;
   int *puntero_int = &valor; // Puntero a int.
   int **puntero_a_puntero = &puntero_int; // Puntero a puntero a int
   int ***puntero_a_puntero_a_puntero = &puntero_a_puntero; // Puntero a puntero a puntero a int
   

3. De-reference : If we use the de-reference operator on a pointer we will access the pointed object, allowing us to modify said object:

   int valor = 0;
   int *puntero_int = &valor; // Puntero a int.
   *puntero_int = *puntero_int + 1;
   

   The example above makes it valorcontain the value 1.

4. Size : If we use the operator sizeofon a pointer, we will always get the same size regardless of the type pointed to, this size will vary depending on the system architecture; normally the size of the pointer matches the size of the processor word :

   char *puntero_char = 0;
   int *puntero_int = 0;
   
   // Esta condicion se cumple siempre.
   if (sizeof(puntero_char) == sizeof(puntero_int)) std::cout << "Eureka!";
   

Qualifiers.

A pointer can be qualified with constor volatilein four different ways:

• No qualifier : This is the qualification we have been looking at so far:

  int *puntero = 0; // Sin cualificadores
  

  This mode allows you to target objects that lack qualifiers:

  int valor = 0;
  int *puntero = &valor;
  

• Qualify the targeted object : The qualification is applied on the targeted object:

  const int *puntero = 0; // Apuntamos a int constantes.
  

  This modality allows you to target objects with the same or lower qualification:

  int valor = 0;
  const int valor_constante = 0;
  // ERROR! 'valor_constante' solo puede ser apuntado por punteros con la misma cualificacion!
  int *puntero = &valor_constante;
  // Correcto! Usamos un puntero a entero constante
  const int *puntero_a_constante = &valor_constante;
  // Correcto! Apuntamos a un objeto con cualificacion inferior
  const int *otro_puntero_a_constante = &valor;
  

  That is, with a pointer we can point to objects that are not qualified as if they were qualified with constor volatile.

• Qualify the pointer : The qualification is applied on the pointer:

  int *const puntero_constante = 0;
  

  Note that the qualifier is after the asterisk ( *), in this case we are creating a constant pointer to a non-constant integer. Since the pointer is constant we cannot make it point to another object but we can modify the pointed object:

  int valor1 = 0;
  int valor2 = 0;
  int *const puntero_constante = &valor1;
  *puntero_constante = *puntero_constante + 1; // valor1 sera 1
  puntero_constante = &valor2; // ERROR! 'puntero_constante' no puede ser cambiado
  

• Qualify both : The qualification is applied to both:

  const int *const valor = 0;
  

  Notice that the qualifier is on both sides of the asterisk ( *), in this case we are creating a constant pointer to a constant object. So we will not be able to modify the value of the object it points to or the object pointed to:

  int valor1 = 0;
  int valor2 = 0;
  const int *const puntero_constante_a_constante = &valor1;
  // ERROR! el objeto apuntado es constante!
  *puntero_constante_a_constante = *puntero_constante_a_constante + 1;
  // ERROR! 'puntero_constante_a_constante' no puede ser cambiado
  puntero_constante_a_constante = &valor2;
  

  As in previous cases, we see that the pointer can point to objects with less restrictive qualifications.

Reference.

References, reference objects, do not contain an address to the referenced object they are the referenced object. For all practical purposes a reference is indistinguishable from the object it references; as an analogy they would be a particle quantumly bonded with another.

Lifecycle.

A reference to a type tipo &only points to an object of type tipoin its life cycle, which is why it is necessary to assign it at the time of its declaration:

int valor1 = 1;
int valor2 = 2;
int &referencia;               // ERROR! 'referencia' necesita referenciar un objeto.
int &otra_referencia = valor1; // Correcto! Referenciamos 'valor1'.

Modification of the targeted object.

References cannot change the object they reference, any assignment operation on a reference will modify the referenced object not the reference:

int valor1 = 1;
int valor2 = 2;
int &referencia = valor1;
referencia = valor2;

the statement referencia = valor2;does not make it referenciarefer to valor2but assigns the value of valor2to the object referenced by referencia, that is: it valor1will get the value 2.

Operations.

1. Arithmetic : Since references only point to an object throughout its life cycle, it is not possible to do arithmetic operations to modify the referenced object; on the contrary, the operations performed on the reference will be applied to the referenced object, not to the reference itself, exactly the same as if the operation were performed on the referenced object:

   int valor1 = 1;
   int &referencia = valor1;
   referencia = referencia + 1;
   

   The example above will cause it to valor1have the value 2no referenciapointing to the next one intin memory.

2. Address of : It is not possible to obtain the memory address of a reference, on the contrary, the memory address obtained would be that of the referenced object:

   int valor = 0;
   int &referencia = valor;
   
   // Esta condicion se cumple siempre.
   if (&valor == &referencia) std::cout << "Eureka!";
   

3. De-reference : Using the de-reference operator on a reference will cause a compile error unless the referenced object accepts the operator:

   int valor = 0;
   struct S { int operator *() { return 0; } } s;
   int &referencia_a_int = valor;
   S &referencia_a_S = s;
   
   std::cout << *referencia_a_int; // ERROR! int no acepta operador unario *
   std::cout << *referencia_a_S; // Correcto! S acepta operador unario *
   

4. Size : If we use the operator sizeofon a reference we will obtain the size of the referenced object:

   char c = 0;
   int i = 0;
   char &referencia_char = c;
   int &referencia_int = i;
   
   // Esta condicion solo se cumple si char e int son del mismo tamanyo.
   if (sizeof(referencia_char) == sizeof(referencia_int)) std::cout << "Oh oh...";
   

Qualifiers.

Since in practice a reference is the same object it references, it is only possible to reference objects with equal or lower qualifications. Unlike with pointers, it is not possible to qualify the reference only to the referenced object, so:

• References without qualification : They can refer to objects without qualification:

  int valor = 0;
  const int valor_constante = 0;
  int &referencia1 = valor;
  int &referencia2 = valor_constante; // ERROR! Se necesita una referencia constante
  

• References with qualification : They can reference objects with and without qualification:

  int valor = 0;
  const int valor_constante = 0;
  // Correcto, referencia constante a objeto no constante
  const int &referencia1 = valor;
  // Correcto! referencia constante a objeto constante 
  const int &referencia2 = valor_constante;
  

• int*represents a pointer.
• int&represents a reference.

How do they look alike?

Internally we can consider that both elements are treated as pointers. That is, when making modifications you are altering the value of a third variable:

    int var = 0;

    int* ptr = &var;
    int& ref = var;

    *ptr = 1;
    std::cout << var; // 1

    ref = 2;
    std::cout << var; // 2

What is the difference between them?

The changes are several:

1. The reference doesn't give you the pointed memory address:

   int var;
   
   int* ptr = &var;
   int& ref = var;
   
   std::cout << (void*)ptr; // Dirección de memoria apuntada por el puntero
   std::cout << (void*)ref; // ¿¿?? No funciona
   

2. You cannot change the object pointed to by a reference:

   int var1, var2;
   
   int& ref = var1;
   ref = var2; // Esto es equivalente a var1=var2.
   &ref = var2; // ERROR!!!
   

3. It cannot be executed deleteon a reference:

   int& func1();
   int* func2();
   
   int& ref = func1();
   delete ref; // ERROR
   delete &ref; // ¿De verdad alguien querría hacer esto?
   
   int* ptr = func2();
   delete ptr; // OK
   

4. In the references it is not necessary to use the indirection operator:

   int& func1();
   int* func2();
   
   int& ref = func1();
   ref = 5; // Nota que no es necesario usar el *
   
   int* ptr = func2();
   *ptr = 5;
   

How do you know when to use each type?

References should be used when you don't need to access any of the features that make them different from pointers, since their use is much simpler and clearer than in the case of pointers.

For example, if a function returns a reference we can assume that we don't have to worry about clearing memory once we're done using the returned variable.