Double Pointers Explained

What is a Pointer to a Pointer?

A regular pointer is a variable that stores the memory address of another variable (like an int or a struct). A pointer to a pointer is simply a variable that stores the memory address of another pointer. It adds another layer of indirection.

Think of it this way:

• A variable holds a value (e.g., 42).
• A pointer holds the address of that value (e.g., address 0x7fff...).
• A double pointer holds the address of the pointer (e.g., address 0x7ffe..., which is where the address 0x7fff... is stored).

The following diagram illustrates this chain of references.

To get a clear visual and code-based introduction, let's watch a short video.

Declaration, Initialization, and Dereferencing

As you saw in the video, the syntax for declaring a double pointer involves two asterisks (**).

Let's break down the mechanics with a code snippet:

#include <stdio.h>

int main() {
    int value = 99;
    
    // A regular pointer to an integer
    int *ptr = &value;
    
    // A pointer to a pointer-to-an-integer
    int **dptr = &ptr;

    printf("--- Addresses ---\n");
    printf("Address of 'value': %p\n", &value);
    printf("Address of 'ptr':   %p\n", &ptr);
    printf("Address of 'dptr':  %p\n", &dptr);
    
    printf("\n--- Values Stored in Pointers ---\n");
    printf("Value stored in 'ptr' (address of 'value'): %p\n", ptr);
    printf("Value stored in 'dptr' (address of 'ptr'):  %p\n", dptr);

    printf("\n--- Dereferencing ---\n");
    printf("Value of 'value':                %d\n", value);
    printf("Value via single dereference (*ptr):  %d\n", *ptr);
    printf("Value via double dereference (**dptr): %d\n", **dptr);
    
    printf("\n--- Intermediate Dereference ---\n");
    // *dptr gives you the value of ptr, which is the address of 'value'
    printf("Value of *dptr (same as ptr): %p\n", *dptr); 
    
    return 0;
}

Here's the key to understanding dereferencing:

• dptr: The double pointer variable itself. Its value is the memory address of ptr.
• *dptr: The first dereference. It "follows the pointer" once to give you the contents of ptr. The content of ptr is the address of value. So, *dptr is equivalent to ptr.
• **dptr: The second dereference. This is equivalent to *(*dptr), which is equivalent to *(ptr). This follows the pointer chain all the way to the end to retrieve the integer 99.

If you prefer a textual explanation, the following resource provides a solid summary.

Use Case: Modifying a Caller's Pointer

Now, let's address the problem from our introduction. How can a function modify a pointer that belongs to its caller? You do this by passing the address of the pointer.

Let's look at a common scenario: a function that allocates memory and returns it through a parameter. This is a frequent pattern in C APIs where the function's return value is used to signal success or failure.

Let's analyze the pattern from the resource:

1. The Caller (main): Has a pointer, int *p, which is uninitialized. It wants the get1024HeapMemory function to make p point to a valid block of allocated memory.
2. Passing the Argument: To allow the function to change p, main passes its address: &p. The type of &p is int **.
3. The Function (get1024HeapMemory): Declares its parameter as int **p_addr. Inside the function, p_addr holds the address of the caller's p.
4. Modification: To access the caller's original p, the function dereferences its parameter: *p_addr. It then assigns the result of malloc to *p_addr. This action directly modifies the p variable back in main.

This technique is essential for your toolkit and is used extensively in C libraries. The video "Making Peace with Double Pointers" also explains this concept clearly, using an example modeled on the POSIX pthread_join function.

#include <stdio.h>
#include <stdlib.h>

int allocate_and_initialize(int **ptr_addr, int value) {
    // 1. Allocate memory for a single int
    int *new_mem = malloc(sizeof(int));

    // 2. Check for allocation failure
    if (new_mem == NULL) {
        return -1; // Failure
    }

    // 3. Store the value
    *new_mem = value;

    // 4. Modify the caller's pointer by dereferencing the double pointer
    *ptr_addr = new_mem;

    // 5. Return success
    return 0;
}

int main() {
    int *my_ptr = NULL; // Good practice to initialize pointers to NULL

    printf("Before call: my_ptr = %p\n", my_ptr);

    if (allocate_and_initialize(&my_ptr, 42) == 0) {
        printf("After call: my_ptr = %p\n", my_ptr);
        printf("Value pointed to by my_ptr: %d\n", *my_ptr);
        
        // Don't forget to free the memory!
        free(my_ptr);
        my_ptr = NULL;
    } else {
        fprintf(stderr, "Memory allocation failed!\n");
    }

    return 0;
}

An Elegant Use Case: Simplifying Linked List Removal

Double pointers aren't just for returning allocated memory; they can also lead to more elegant and efficient algorithms. One of the most famous examples comes from Linus Torvalds, the creator of Linux. He demonstrated how using a pointer-to-a-pointer can simplify the code for removing an element from a singly-linked list.

The key idea is that the pointer you need to change is either the list_head itself (if removing the first element) or the next field of the previous element. A struct list_entry ** can point to either of these, allowing you to treat both cases with a single line of code: *pp = entry->next;. This is a powerful demonstration of how a deeper understanding of pointers leads to cleaner, more robust code.

Conclusion

Today we've added a crucial tool, the double pointer, to your C programming arsenal. You've seen that it's more than just a syntactic curiosity; it's the standard C idiom for allowing functions to modify pointers passed by a caller, and it can even lead to more elegant algorithms. Your experience in software architecture will help you appreciate how this feature enables the creation of modular and flexible C APIs.

Key Takeaways:

• A double pointer (type **) is a variable that stores the memory address of another pointer.
• It provides an additional level of indirection, requiring two dereferences (**) to access the final value.
• The primary use case is to pass a pointer to a function by reference, allowing the function to modify the caller's original pointer variable. This is essential for functions that allocate memory for the caller.
• Advanced use of double pointers, as seen in the linked-list example, can help eliminate special cases and make algorithms more generic and robust.

Preview of the Next Lesson:
We've seen that char **argv can be used to handle command-line arguments, which is effectively an array of strings. This syntax, where a double pointer is used with arrays, can sometimes be confusing. Is int **p the same as a 2D array int a[10][10]? (Hint: it's not). In the next lesson, we will dive into these nuances and learn to distinguish between a pointer to an array and an array of pointers, which is critical for correctly navigating multi-dimensional data structures in C.