Pointers and Pointers to Pointers in C: Using Multilevel Pointers

In C, pointers are a very important concept. They can be used not only to directly manipulate memory but also to implement complex data structures and algorithms. In this article, we will delve into the use of pointers and multilevel pointers (i.e., “pointers to pointers”).

What is a Pointer?

In C, a pointer is a variable whose value is the address of another variable. By using pointers for indirect access to variables, memory can be effectively managed, and program performance can be improved.

Basic Syntax of Pointers

Define an integer variable and its corresponding integer pointer:

int a = 10;      // Define an integer variable
int *p = &a;    // Define an integer pointer p and initialize it to the address of a

Here, the & operator is used to get the address of the variable a, while *p indicates accessing the original data through that address.

Usage Example

Below is a simple example demonstrating how to modify data using a regular single-level pointer:

#include <stdio.h>
int main() {    int a = 10;    int *p = &a;
    printf("Before: a = %d\n", a); // Output: Before: a = 10
    *p = 20; // Modify the data pointed to by p
    printf("After: a = %d\n", a); // Output: After: a = 20
    return 0;}

What is a Multilevel Pointer?

Multilevel pointers are a special type of reference that allows us to create indirect references at multiple levels. For example, a “double” or “triple” or higher-level reference can be referred to as a multilevel pointer. The most common are double (i.e., “pointer to pointer”) and triple (i.e., “pointer to pointer to pointer”).

Double Pointer Correspondence

A double pointer corresponds to the following situation:

int **pp: pp is a one-dimensional array of integers, where each element is another one-dimensional array of integers.

Example Code

Now let’s look at how to define and use a double pointer:

#include <stdio.h>
int main() {    int value = 30;       // Define an integer variable value
    int *p1 = &value;     // p1 is a single pointer, storing the address of value
    int **p2 = &p1;       // p2 is a double pointer, storing the address of single pointer p1
    printf("Value using single pointer: %d\n", *p1);   // Output: 30
    printf("Value using double pointer: %d\n", **p2);   // Output: 30
    **p2 += 10;           // Modify the value of value through the double pointer
    printf("New Value after modification: %d\n", value);   // Output: 40
    return 0;}

In this example, we first defined an integer value, then created pointers at two levels. Through these pointers, we were able to indirectly modify the original data.

Multilevel Nesting and Application Scenarios

While usually only one or two levels are needed, sometimes more levels may be encountered, such as triple, quadruple, etc. These are often used to handle complex data structures like linked lists, trees, etc.

Triple and Higher Order Example Code

Here is an example of a triple pointer:

#include <stdio.h>
int main() {
   int value3D[3] = {100, 200, 300};    int *ptr1D[3]; 
   for (int i=0; i<3; i++) {       ptr1D[i] =&value3D[i];    }
   int **ptr2D= ptr1D;
   for (int j=0;j<3;j++){       printf("Value at index %d is :%d \n", j, *(ptr2D[j]));   }
   return 0;}

In this example, we created three different one-dimensional arrays, and used each element in the one-dimensional array as the second dimension, then used the second dimension as the third dimension, thus achieving access to a three-dimensional data structure.

Conclusion

This article introduced the basic concepts in C—single and multilevel (double/triple) pointers. Understanding these concepts is crucial for mastering dynamic memory allocation, complex data structures, and function parameter passing. In practical programming, multilevel design can help you build more flexible and efficient software systems. Therefore, during the learning process, be sure to deepen your understanding of these concepts and practice them.