String de Punteros en C con Ejemplos

Requisito previo: Punteros en C , Puntero doble (Puntero a puntero) en C
Se utiliza un puntero para apuntar a una ubicación de memoria de una variable. Un puntero almacena la dirección de una variable.
De manera similar, una string de punteros es cuando hay múltiples niveles de punteros. Simplificando, un puntero apunta a la dirección de una variable, un doble puntero apunta a una variable y así sucesivamente. Esto se llama direcciones indirectas múltiples .
Sintaxis: 
 

// level-1 pointer declaration
datatype *pointer; 

// level-2 pointer declaration
datatype **pointer; 

// level-3 pointer declaration
datatype ***pointer; 
.
.
and so on

El nivel del puntero depende de cuántos asteriscos preceda la variable de puntero en el momento de la declaración.
Declaración: 
 

int *pointer_1;
int **pointer_2;
int ***pointer_3;
.
.
and so on

El nivel de punteros o digamos string puede subir al nivel N dependiendo del tamaño de la memoria. Si desea crear un puntero de nivel 5, debe preceder el nombre de la variable del puntero con 5 asteriscos (*) en el momento de la declaración. 
Inicialización: 
 

// initializing level-1 pointer
// with address of variable 'var'
pointer_1 = &var;

// initializing level-2 pointer
// with address of level-1 pointer
pointer_2 = &pointer_1;

// initializing level-3 pointer
// with address of level-2 pointer
pointer_3 = &pointer_2;
.
.
and so on

Ejemplo 1: 
 

Como se muestra en el diagrama, la variable ‘a’ es una variable entera normal que almacena el valor entero 10 y está en la ubicación 2006. ‘ptr1’ es una variable de puntero que apunta a la variable entera ‘a’ y almacena su ubicación, es decir, 2006, como su valor. De manera similar, ptr2 apunta a la variable de puntero ptr1 y ptr3 apunta a la variable de puntero ptr2. Como cada puntero apunta directa o indirectamente a la variable ‘a’, todos tienen el mismo valor entero que la variable ‘a’, es decir, 10
Entendamos mejor con el siguiente código:
 

#include <stdio.h>
// C program for chain of pointer
 
int main()
{
    int var = 10;
 
    // Pointer level-1
    // Declaring pointer to variable var
    int* ptr1;
 
    // Pointer level-2
    // Declaring pointer to pointer variable *ptr1
    int** ptr2;
 
    // Pointer level-3
    // Declaring pointer to double pointer **ptr2
    int*** ptr3;
 
    // Storing address of variable var
    // to pointer variable ptr1
    ptr1 = &var;
 
    // Storing address of pointer variable
    // ptr1 to level -2 pointer ptr2
    ptr2 = &ptr1;
 
    // Storing address of level-2 pointer
    // ptr2 to level-3 pointer ptr3
    ptr3 = &ptr2;
 
    // Displaying values
    printf("Value of variable "
           "var = %d\n",
           var);
    printf("Value of variable var using"
           " pointer ptr1 = %d\n",
           *ptr1);
    printf("Value of variable var using"
           " pointer ptr2 = %d\n",
           **ptr2);
    printf("Value of variable var using"
           " pointer ptr3 = %d\n",
           ***ptr3);
 
    return 0;
}

Value of variable var = 10
Value of variable var using pointer ptr1 = 10
Value of variable var using pointer ptr2 = 10
Value of variable var using pointer ptr3 = 10

Ejemplo 2: Considere el código dado a continuación donde hemos tomado el tipo de datos flotante de la variable, por lo que ahora también tenemos que tomar el mismo tipo de datos para la string de punteros. Dado que el puntero y la variable a la que apunta deben tener el mismo tipo de datos.
 

#include <stdio.h>
int main()
{
    float var = 23.564327;
 
    // Declaring pointer variables upto level_4
    float *ptr1, **ptr2, ***ptr3, ****ptr4;
 
    // Initializing pointer variables
    ptr1 = &var;
    ptr2 = &ptr1;
    ptr3 = &ptr2;
    ptr4 = &ptr3;
 
    // Printing values
    printf("Value of var = %f\n", var);
    printf("Value of var using level-1"
           " pointer = %f\n",
           *ptr1);
    printf("Value of var using level-2"
           " pointer = %f\n",
           **ptr2);
    printf("Value of var using level-3"
           " pointer = %f\n",
           ***ptr3);
    printf("Value of var using level-4"
           " pointer = %f\n",
           ****ptr4);
 
    return 0;
}

Value of var = 23.564327
Value of var using level-1 pointer = 23.564327
Value of var using level-2 pointer = 23.564327
Value of var using level-3 pointer = 23.564327
Value of var using level-4 pointer = 23.564327

Ejemplo 3: Actualizar variable usando un puntero enstringdo 
Como ya sabemos que un puntero apunta a la ubicación de la dirección de una variable, cuando accedemos al valor del puntero apuntará al valor de la variable. Ahora, para actualizar el valor de la variable, podemos usar cualquier nivel de puntero ya que, en última instancia, cada puntero apunta directa o indirectamente solo a esa variable. Cambiará directamente el valor presente en la ubicación de la dirección de la variable.
 

#include <stdio.h>
 
int main()
{
    // Initializing integer variable
    int var = 10;
 
    // Declaring pointer variables upto level-3
    int *ptr1, **ptr2, ***ptr3;
 
    // Initializing pointer variables
    ptr1 = &var;
    ptr2 = &ptr1;
    ptr3 = &ptr2;
 
    // Printing values BEFORE updation
    printf("Before:\n");
    printf("Value of var = %d\n", var);
    printf("Value of var using level-1"
           " pointer = %d\n",
           *ptr1);
    printf("Value of var using level-2"
           " pointer = %d\n",
           **ptr2);
    printf("Value of var using level-3"
           " pointer = %d\n",
           ***ptr3);
 
    // Updating var's value using level-3 pointer
    ***ptr3 = 35;
 
    // Printing values AFTER updation
    printf("After:\n");
    printf("Value of var = %d\n", var);
    printf("Value of var using level-1"
           " pointer = %d\n",
           *ptr1);
    printf("Value of var using level-2"
           " pointer = %d\n",
           **ptr2);
    printf("Value of var using level-3"
           " pointer = %d\n",
           ***ptr3);
 
    return 0;
}

Before:
Value of var = 10
Value of var using level-1 pointer = 10
Value of var using level-2 pointer = 10
Value of var using level-3 pointer = 10
After:
Value of var = 35
Value of var using level-1 pointer = 35
Value of var using level-2 pointer = 35
Value of var using level-3 pointer = 35

Nota: El puntero de nivel N solo se puede usar para señalar el puntero de nivel (N-1). Excepto para el puntero de nivel 1. El puntero de nivel 1 siempre apuntará a la variable.