cout << *puntero1 <<endl;

• Por un lado un identificador de esa variable. Un valor que representa unívocamente la variable -> Su dirección de memoria. No puede variar durante la ejecución.
• Por otro lado el contenido almacenado en ese espacio. El valor que se guarda en esa variable. Puede variar durante la ejecución.

• Puntero: Variable que su contenido es siempre una dirección de memoria. Al ser así los punteros tienen 2 direcciones de memoria: una de ellas es su identificador y la otra es su contenido.
• Operador * (asterisco): Desreferencia un puntero. Hace que el puntero no devuelva la dirección de memoria que tiene almacenada en su contenido sino que devuelve el contenido de esa dirección de memoria. Excepción: En la línea en que se define el puntero, el operador * no desreferencia, sólo indica que se está declarando un puntero.
  
  Código:
  Suponemos que la posición de memoria 0x1234 contiene el valor 8
  Puntero p = 0x1234 -> Un puntero siempre contiene direcciones de memoria
  Mostrar p -> Muestra (el contenido de p): 0x1234
  Mostrar *p -> Muestra (el contenido de la dirección de memoria 0x1234): 8
• Operador & (ampersand): Se puede aplicar a cualquier variable. Obtiene la dirección de memoria de esa variable (su identificador único e invariable) en vez de su contenido.
  
  
  Código

  int main() {
    int a = 5; // El programa reserva la posicion 0x1 de la memoria (para a) y guarda en su interior el valor 1. Lo representare a partir de ahora como -> 0x1(5)
   
    int *p = &a; // El programa reserva la posicion 0x2 de la memoria (para p) y guarda en su interior la direccion de memoria de a (0x1) -> 0x2(0x1)
   
    cout << "El valor de a es: " << a << " y su direccion de memoria es: " << &a << endl; // Muestra: "El valor de a es: 5 y su direccion de memoria es: 0x1"
    cout << "El valor de p es: " << p << " y su direccion de memoria es: " << &p << endl; // Muestra: "El valor de p es: 0x1 y su direccion de memoria es: 0x2"
    cout << "Desreferenciamos p: " << *p << endl; // Muestra: "Desreferenciamos p: 5"
   
    // Ahora vamos a probar a cambiar valores a ver que pasa
    int b = 8; // El programa reserva la posicion 0x3 de la memoria (para b) y guarda en su interior el valor 8 -> 0x3(8)
    *p = b; // Que pasa aqui? No se cambia la direccion de memoria que contiene p (0x1). Se cambia el valor que hay dentro de 0x1 (5). 0x1 es la direccion de memoria que identifica a la variable a -> 0x1(8)
    cout << "El valor de a es: " << a << " y su direccion de memoria es: " << &a << endl; // Muestra: "El valor de a es: 8 y su direccion de memoria es: 0x1"
    // Hemos cambiado el contenido de a (5 -> 8) pero su direccion de memoria no varia, sigue siendo 0x1
    cout << "El valor de p es: " << p << " y su direccion de memoria es: " << &p << endl; // Muestra: "El valor de p es: 0x1 y su direccion de memoria es: 0x2" -> Como vemos esto no ha cambiado nada
    cout << "Desreferenciamos p: " << *p << endl; // Muestra: "Desreferenciamos p: 8" -> Esto si ha cambiado porque el contenido de 0x1 ahora es 8, no 5
   
    // Hasta aqui todo bien supongo. Asequible, pero... y ahora que?
    int **pp = &p; // El programa reserva la posicion 0x4 de la memoria (para pp) y guarda en su interior la direccion de memoria de p (0x2) -> 0x4(0x2)
    // Al usar ** estamos declarando un puntero a puntero. Un puntero que guarda como valor la direccion de memoria de otro puntero
    // Ahora vamos a comprobar que se sigue cumpliendo lo que decimos:
    cout << "El valor de pp es: " << pp << " y su direccion de memoria es: " << &pp << endl; // Muestra: "El valor de pp es: 0x2 y su direccion de memoria es: 0x4"
    cout << "Desreferenciamos pp: " << *pp << endl; // Muestra: "Desreferenciamos pp: 0x1"
    // Aclaremos la linea anterior: Al desreferenciar un puntero no mostramos la direccion de memoria que contiene sino el contenido de esa direccion de memoria
    // pp contiene 0x2 -> Al desreferenciar obtenemos el valor que se guarda dentro de la direccion 0x2 y si vamos a la linea de p vemos que el valor que guarda la direccion 0x2 es: 0x1  &#8203;
   
    // Ahora entonces como *p devuelve una direccion de memoria (un puntero), podemos ver que contiene esa direccion de memoria (podemos desferenciarlo de nuevo):
    cout << "Desreferenciamos *pp: " << **pp << endl; // Muestra: "Desreferenciamos *pp: 8" -> Si *pp devuelve 0x1, el contenido de la direccion 0x1 es: 8
  } 

  
  Se acabó el programa y la tabla de direcciones de memoria y contenido es:
  
  Código:
  Variable a -> Direccion de memoria: 0x1 -> Contenido: 8
  Variable p -> Direccion de memoria: 0x2 -> Contenido: 0x1
  Variable b -> Direccion de memoria: 0x3 -> Contenido: 8
  Variable pp -> Direccion de memoria: 0x4 -> Contenido: 0x2

  ---

  RESUMEN
  -------------------
  - Todas las variables están formadas por una dirección de memoria y un contenido.
  - Las direcciones de memoria de cada variable las asigna el sistema operativo y no se pueden modificar.
  - El contenido de las variables puede ser un valor o una dirección de memoria (en el caso de los punteros). El contenido lo asignamos nosotros y se puede modificar.
  
  
  PD: Se me ha podido pasar algún error en el código. De ser así no dudéis en avisarme para corregirlo pues es un tema en el que la exactitud es muy importante.
  PD2: El código hay que estudiarlo sin prisa, hacer las pruebas que consideréis y preguntar cualquier duda que os pueda quedar.