How many levels of pointers can you have? in C programming

How many levels of pointers can you have?

The answer depends on what you mean by “levels of pointers.” If you mean “How many levels of indirection
can you have in a single declaration?” the answer is “At least 12.”

int i = 0;
int *ip01 = & i;
int **ip02 = & ip01;
int ***ip03 = & ip02;
int ****ip04 = & ip03;
int *****ip05 = & ip04;
int ******ip06 = & ip05;
int *******ip07 = & ip06;
int ********ip08 = & ip07;
int *********ip09 = & ip08;
int **********ip10 = & ip09;
int ***********ip11 = & ip10;
int ************ip12 = & ip11;
************ip12 = 1; /* i = 1 */

NOTE
The ANSI C standard says all compilers must handle at least 12 levels. Your compiler might
support more.
If you mean “How many levels of pointer can you use before the program gets hard to read,” that’s a matter
of taste, but there is a limit. Having two levels of indirection (a pointer to a pointer to something) is common.
Any more than that gets a bit harder to think about easily; don’t do it unless the alternative would be worse.
If you mean “How many levels of pointer indirection can you have at runtime,” there’s no limit. This point
is particularly important for circular lists, in which each node points to the next. Your program can follow
the pointers forever. Consider the following (rather dumb) example in Listing VII.2.

A circular list that uses infinite indirection.

/* Would run forever if you didn’t limit it to MAX */
#include <stdio.h>
struct circ_list
{
char value[ 3 ]; /* e.g., “st” (incl ‘\0’) */
struct circ_list *next;
};
struct circ_list suffixes[] = {
“th”, & suffixes[ 1 ], /* 0th */
“st”, & suffixes[ 2 ], /* 1st */
“nd”, & suffixes[ 3 ], /* 2nd */
“rd”, & suffixes[ 4 ], /* 3rd */
“th”, & suffixes[ 5 ], /* 4th */
“th”, & suffixes[ 6 ], /* 5th */
“th”, & suffixes[ 7 ], /* 6th */
“th”, & suffixes[ 8 ], /* 7th */

th”, & suffixes[ 9 ], /* 8th */
“th”, & suffixes[ 0 ], /* 9th */
};
#define MAX 20
main()
{
int i = 0;
struct circ_list *p = suffixes;
while (i <= MAX) {
printf( “%d%s\n”, i, p->value );
++i;
p = p->next;
}

Each element in suffixes has one suffix (two characters plus the terminating NUL character) and a pointer
to the next element. next is a pointer to something that has a pointer, to something that has a pointer, ad
infinitum.

The example is dumb because the number of elements in suffixes is fixed. It would be simpler to have an
array of suffixes and to use the i%10’th element. In general, circular lists can grow and shrink; they’re much
more interesting than suffixes in Listing VII.2.

Cross Reference:

VII.1: What is indirection?