Go Pointer to Pointer (Double Pointer)

In Go, you can have pointers to pointers, also known as double pointers. This concept is particularly useful when you need to modify the value of a pointer itself, such as when dynamically allocating memory or when you want to pass a pointer by reference to a function. Here’s an example of using a pointer to a pointer:

package main

import "fmt"

func main() {
    x := 42
    p := &x         // Pointer to x
    pp := &p        // Pointer to the pointer p

    fmt.Println("Value of x:", x)
    fmt.Println("Value pointed to by p:", *p)
    fmt.Println("Value of p (address of x):", p)
    fmt.Println("Value pointed to by pp (value of p):", *pp)

    // Modifying the value of x through the pointer to pointer
    **pp = 99

    fmt.Println("Value of x after modification:", x)
}

Output:

Value of x: 42
Value pointed to by p: 42
Value of p (address of x): 0xc0000140a0
Value pointed to by pp (value of p): 0xc0000140a0
Value of x after modification: 99

In this example, we start by creating an integer variable x. We then create a pointer p that points to x, and a pointer pp that points to the pointer p. By using *p, we access the value of x, and by using *pp, we access the value of p. Since p is a pointer to x, and pp is a pointer to p, modifying **pp is equivalent to modifying the value of x.

Using pointers to pointers allows you to work with the value of a pointer itself, which can be useful in situations where you need to update a pointer’s value dynamically.

Here’s another example that demonstrates the concept of pointers to pointers (double pointers) with a dynamic memory allocation scenario:

package main

import "fmt"

func allocateMemory(val int) **int {
    p := new(int)    // Create an int pointer
    *p = val         // Set the value of the int pointer

    pp := &p         // Create a pointer to the int pointer
    return pp        // Return the pointer to pointer
}

func main() {
    pp := allocateMemory(42)  // Get the pointer to pointer

    fmt.Println("Value of x (through double pointer):", **pp)
}

Output : 

Value of x (through double pointer): 42

In this example, the allocateMemory function dynamically allocates memory for an integer using new(int). It then sets the value of the integer through the pointer p. After that, it creates a pointer pp that points to the pointer p, effectively returning a pointer to pointer from the function.

In the main function, we call allocateMemory with the value 42 and get a pointer to pointer. By using **pp, we can access the value of the integer that was allocated dynamically in the allocateMemory function.

This example illustrates how double pointers can be used to handle scenarios where you need to modify or return pointers dynamically.