Un beneficio de utilizar dobles puntero dependiendo de lo que vallas a hacer con tu programa es hacer mejor uso de memoria dinamica.

Hace unos dias participe en el siguiente tema    
Re: Sistema de cifrado por lote de texto plano

Deje el codigo y utliza dobles punteros para almacenar unas listas de longitud dinámica cada lista.

El detalle que si los usas mal y/o no asginas y/o liberas memoria incorrectamente terminaras haciendo un completo desmadre y posiblemente el programa termine colgándose.

Imaginate esto, quieres hacer un programa que almacene las calificaciones de todos los alumnos de una escuela para despues hacer cualquier otro proceso con ellos.

int **calificaciones;

Estamos de acuerdo que la instrucción anterior solo "reserva" en la pila un espacio para guardar un apuntador.

int i,j;
int *alumnosXsalon;
int **calificaciones;

Mientras tanto en la pila se muestra asi (Uso 4 bytes para los int, y para los apuntadores asumo que estamos en un sistema x86):

Pila:


Asignamos memoria para nuestra variable calificaciones Asumimos que son 30 salones, incluso se podria ser variable menos salones o mas salones incluso mil o un millon suponiendo que hay memoria suficiente no sera problema reservarla.

calificaciones = calloc(30,sizeof(int*));
 

Como mencione si el apuntador es de 4 bytes, se nos devolvera una direccion de memoria de longitud 30x4 bytes y como es la funcion calloc la memoria esta limpia esto es los 120 bytes estaran en 0 cada uno.

calificaciones => [Bloque de 120 continuos]

ahora bien la variable calificaciones apunta a un espacio en memoria de 120 bytes donde podemos guardar lo que queramos, pero siguiendo con el ejemplo de apuntadores damos por hecho que cada 4 bytes es un apuntador a otra direccion de memoria (Actualmente no apuntan a ningun lugar ya que no hemos inicializado esos 30 apuntadores).

Como es un ejemplo didactico supondre que alumnosXsalon ya esta inicializado y es un arreglo 30 de enteros y cada uno indica la cantidad de alumnos en cada salon por ejemplo

alumnosXsalon = {20, 30, 10 , 24, 12, 3, 8, 18 , .....}

Ahora vamos a inicializar esos 30 apuntadores:

i = 0
while(i < 30)	{
	calificaicones[i] = calloc(alumnosXsalon[i],sizeof(int));
	i++;
}
 

Con esto logramos reservamos la memoria para todas las calificaciones.

calificaciones ==>> [120 bytes, cada 4 bytes es un apuntador a otra segmento de memoria]

o ma claro aun

calificaciones => [[1ros apuntador => 20 enteros],[2do apuntador => 30 enteros], .... ]

Y ahora solo queria escribir las cientos de calificaciones en sus respectivos espacios asignados

Para entenderlo mejor ha que aprender a depurar un poco el código y mostrar las direcciones de memoria sus valores antes y depues asi como a donde estan apuntando.

Si dominas esto entenderas muy bien los apuntadores lo cual es una de las mejores caracteristicas del lenguaje C

Ejemplo comentado:

#include<stdio.h>
#include<stdlib.h>
 
int main()	{
	int i,j;
	int alumnosXsalon[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30};
	int **calificacion;
	printf("i esta en 0x%.8x: [%i]\n",&i,i);
	printf("j esta en 0x%.8x: [%i]\n",&j,j);
	printf("alumnosXsalon esta en 0x%.8x: => %X\n",&alumnosXsalon,alumnosXsalon);
	printf("calificacion esta en 0x%.8x: => %X aun no se reserva memori\n",&calificacion,calificacion);
	calificacion = calloc(30,sizeof(int*));
	printf("calificacion esta en 0x%.8x: => %X ya se reservo la memoria\n",&calificacion,calificacion);
	i=0;
	while(i < 30)	{
		printf("Reservado %i bytes\n",(alumnosXsalon[i]*sizeof(int)));
		calificacion[i] = calloc(alumnosXsalon[i],sizeof(int));
		printf("calificacion[%i] esta en 0x%.8x: => %X un segmento de %i bytes \n",i,calificacion + i,calificacion[i],(alumnosXsalon[i]*sizeof(int)));
		i++;
	}
}
 

Salida


Respondiendo tus preguntas:

Por ahí leí que los punteros dobles se asemejan a los array de 2 dimensiones, es esto cierto y porque?.

No del todo, depende de como se usen.
Si declaras un array de 2 dimenciones por ejemplo 15x10 es y sera siempre de 15x10.
En cambio si apuntador lo declaras de 15 x 10 es en ese momento de 15x10 y se podria quedar asi o modificarse, liberar la memoria asginar algunos elementos (digamos los primeros 5) a una longitud de solo 7 por ejemplo. Si se asemejan paro para fines didacticos pero los apuntadores son mejores. Ve el ejemplo anterior tengo un apuntador dinamico de 30 apuntadores apuntado a 1, 2, 3, 4, .. respectivamente,

Buen dia.

Entiendo lo que dices, en su momento yo tambien no entendia los apuntadores pero como lo mencione es una de las mejores caracteristicas del lenguaje.

Asumi erroneamente por tu pregunta (Dobles apuntadores) que ya sabias lo que es un apunador.

Un apuntador independientemente del tipo de variable que sea, es una variable que apunta a una direccion de memoria.

Apuntar a un puntero parece una redundancia pero tiene sus usos:

1. Construcción de una tabla de forma dinámica:
Para un compilador que no implemente el estándar C99 o superior la única forma de obtener una tabla de MxN de la que las dimensiones no se conocen en tiempo de programación (a partir de ahora en tiempo de compilación) es usando punteros e instrucciones alloc. Ejemplo:

int **tabla;
int m, n;
int i;
 
/* Se obtienen las dimensiones de la tabla m y n
 * n para el número de filas
 * m para el número de columnas
 */
 
/* Se genera el primer array dinámico que contendrá n filas */
 
tabla = malloc(sizeof(int*) * filas);
 
/* Las filas son punteros porqué contendrán la dirección de inicio
 * del array columnas.
 * Por tanto, para cada elemento de filas, reservamos una porción de
 * memoria de m elementos.
 */
 
for(i = 0; i < filas; ++i)
    tabla[i] = malloc(sizeof(int) * columnas);  /* Se puede apreciar notación de array para un puntero */
 

2. Construcción de una tabla de diente de sierra.
Es parecido al anterior pero con la ventaja de que se gasta menos memoria.
Si, por ejemplo, se necesita una tabla de la siguiente forma:
123456
123
1
123456
123
Se puede generar de la siguiente manera:

int **tabla;
int m, n;
int i;
 
/* Obtenemos el número de filas: n */
tabla = malloc(sizeof(*int) * n);
 
for(i = 0; i < n; ++i) {
 
    /* Obtenemos el número de columnas m de la fila actual i */
 
    /* Creamos el array de m columnas */
    tabla[i] = malloc(sizeof(int) * m);
}

3. Cambiar la dirección a la que apunta un puntero e una función externa
Tenemos un dato definido por nosotros, por ejemplo una lista, y decidimos que tenga una funcinalidad, una función, que borre un nodo y deje ese puntero del nodo  NULL para no tener problemas extraños si más adelante se referenciara ese nodo borrado: al ser NULL se pararía el programa y se lanzaría un mensaje de error, con lo que nos ayudaría con la depuración.

La función sería así:

/* Supongamos lo siguiente */
typedef struct node_t {
    int i;
    node_t *next;
} node;
 
void free_node(node **n) {
    node *aux = *n;
    if(aux) {
        free(aux);
        *n = NULL;
}
 
/* === Código que llama a la función === */
/* Supongamos nodo como un elemento que ya tiene memoria asignada
 * con malloc, es decir: * 
 * node *nodo = malloc(sizeof(node));
 * o una función que genere e inicialice un dato node.
 * Ya hemos trabajado con él y ahora debemos borrarlo. Además
 * se debe llevar a NULL el puntero, por lo que haremos uso
 * de la función free_node que forma parte de las funciones de éste tipo
 * de datos.
 */
 
free_node(&nodo);

Hay más funcionalidades para punteros a punteros, pero estas son las más comunes. Ya las irás viendo a medida que avances con C.