[gladius]

Los punteros apuntan a una dirección de memoria. No es lo mismo que obtenga el valor a que obtenga la dirección de memoria del valor.

Puedes usar dos operadores básicos dentro de los punteros. &(Direccionamiento) y *(Indireccionamiento)

Sintaxis:

int *ptrA, A;
A = 5;
ptrA = &A; // puntero a la variable A

ptrA es un puntero a int, mientras que la variable A es solo una variable del tipo int.
Todo puntero debe ser precedido por un asterisco (*).
Un puntero si es constante NO PUEDE ser modificado. int *const ptrA = 5; Puede alterarse solo si apunta a una variable y esta se modifica.

Si tengo un puntero A que apunta a la posición X y tengo otro puntero B que apunta a X, si yo modifico el puntero A, el puntero B se va a modificar también. Si yo modifico la variable X, ambos punteros se van a modificar.

Te dejo unos ejemplos hechos por mi, ojalá los entiendas y conozcas alguno de sus usos. (Están hechos en un compilador no muy bueno Dev c++)

// Operadores Simples

#include <iostream>
using namespace std;

main()
{
      int a = 3, *b = &a;
      
      cout << "a: " << a << endl << "b: " << b << " ( " << *b << " )" << endl;
      
      system("pause");
}

// Operadores Simples con puntero constante

#include <iostream>
using namespace std;

main()
{
      int a = 3;
      const int * const b = &a;
      
      cout << "a: " << a << " - b: " << *b << endl;
      a = 5;
      cout << "a: " << a << " - b: " << *b << endl;      
      
      system("pause");
}

// Función valor por referencia.

#include <iostream>
using namespace std;

// Esta Función permite que la variable b
void Funcion(int *a)
{
       *a+= (*a * 2);  
}

main()
{
      int b = 5;
      
      cout << "valor: " << b << endl;
      Funcion(&b); // La variable b obtiene su nuevo valor, sin necesidad de hacer que la variable retorne el resultado de la función
      cout << "valor: " << b << endl;
      
      system("pause");
}

// Retornar un arreglo de Enteros

#include <iostream>
using namespace std;

int *Arreglo(int a)
{
       int i, Arr[10];
       
       for(i = 0; i < 10; i++)
       {
              Arr[i] = a + (i * 2);
       }
       
       return Arr;
}

main()
{      
      int a, *b;
      
      b = Arreglo(5); 
      a = *(b + 2); // b sería el primer elemento del arreglo, entonces b + 2 es el 3er elemento. SE DEBE RESPETAR EL PARENTESIS.
      
      cout << "valor: " << a << endl;
      
      system("pause");
}

// Recorrer un Arreglo de Enteros

#include <iostream>
using namespace std;
 
main()
{
    int arr[6] = { 1, 3, 5, 7, 9, 20 };
    int *a;
 
    a = arr; // Puntero toma valor del arreglo int
 
    // La x es el valor que se va a mostrar
    cout << *a << endl; //[x][3][5][7][9][20]
    a+= 2;
    cout << *a << endl; //[1][3][x][7][9][20]
    a-= 1;
    cout << *a << endl; //[1][x][5][7][9][20]
    a+= 4;
    cout << *a << endl; //[1][3][5][7][9][x]
    a-= 2;
    cout << *a << endl; //[1][3][5][x][9][20]
    
    system("pause");
}

// Punteros entre funciones

#include <iostream>
using namespace std;

//Una función es la dirección de memoria de donde comienza el código. Por ende se puede retornar entre funciones.
bool functionA(int param1, bool (*verificar)(int))
{
        if(((*verificar)(param1)))
        {
                return true;
        }
        return false;
}
 
bool functionB(int param)
{
        if(param & 1) // Es una forma de obtener los números impares mediante el uso de operadores Binarios
        {
                return false;
        }
        else
        {
                return true;
        }
}
 
main()
{
    int x = 110;
    bool a = functionA(x, functionB); // El segundo parametro es un puntero a la función B
    
    if(a)
    {
          cout << "Es Par" << endl;
    }
    else
    {
          cout << "Es Impar" << endl;
    }
                
    system("pause");
}

También te voy a agregar uno de una lista enlazada, no es complicado de entender.

#include <iostream>
using namespace std;

class Nodo {
	private:
	        int value;                  
	
	public:
	        Nodo *next;
	        Nodo(int value) // Constructor
            {
		         this->value = value;
		         next = NULL;
	        }
        	int GetValue() 
            {
        		return value;
        	}
};

main()
{
      int val, i;
      Nodo *head = NULL, *aux2;   
      
      for(i = 0; i < 4; i++)
      {       
              cout << "Ingresa Un valor: ";
              cin >> val;   
              
              if(head == NULL)
	          {
					 head = new Nodo(val);     
                     aux2 = head;                           
			  }
				
			  else
			  {
					 Nodo *body = head;
					
					 while(body->next != NULL)
					 {
						  body = body->next;
				     }
					
					 body->next = new Nodo(val); 	
			  }
      }
     
      cout << endl << "Listando..." << endl;	
			
	  Nodo *aux = aux2;		
      while(aux != NULL)
      {
			 cout << aux->GetValue() << endl;	     
			 aux = aux->next;
      } 
      system("pause");
}

Disculpa pero no sé como redactarlo de una mejor forma más teórica.

Quiero agregar por último que cuando veas Nodos, Lista enlazada, Stacks, Queue, Arbol binario y otros métodos avanzados, vas a utilizar MUCHO los punteros.