Pointer to Pointer in Objective-C

Pointers in Objective-C are a powerful and essential concept for any programmer to master. Pointers allow you to manipulate data stored in memory directly and are used to store the address of a variable. Pointer-to-pointer also known as a double pointer, is a type of pointer that holds the address of another pointer. The pointer-to-pointer concept is often used in situations where you need to pass a pointer as an argument to a function or to store a dynamically allocated object.

There are three types of pointers in Objective-C: a regular pointer, a pointer to constant, and a constant pointer. A regular pointer holds the address of a variable, while a pointer to a constant holds the address of a constant value. A constant pointer holds a constant address and cannot be changed.

Pointer to Pointer

A pointer to pointer, or double pointer, is a type of pointer that holds the address of another pointer. A double pointer is declared using two asterisks (**) in the declaration, such as int p, where p is a double pointer. The first asterisk (*) represents the type of data stored at the address held by the pointer, and the second asterisk () represents that it is a pointer to a pointer.

Syntax:

The syntax for declaring a pointer-to-pointer is similar to that of a regular pointer, with two asterisks used to indicate that it is a pointer to a pointer. 

data_type **pointer_name;

Example: int **p;

Here, pointer to pointer includes &, *, and **. The & operator is used to get the address of a variable, while the * operator is used to access the value stored at the address held by the pointer. The ** operator is used to access the value stored at the address held by a pointer to a pointer.

Example 1: 

// Objective-C Program to illustrate pointer to
// pointer to pass a pointer as an argument to a function
#import <Foundation/Foundation.h>

// Function that takes two pointer to pointers
// as arguments and swaps their values
void swap(int **p, int **q) 
{

    // Store the value of *p in a temporary variable
    int *temp = *p; 
    
    // Assign the value of *q to *p
    *p = *q; 
    
    // Assign the value of temp to *q
    *q = temp; 
}

int main(int argc, const char * argv[]) 
{
    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
    
    // Declare two integers
    int a = 10, b = 20; 
    
     // Declare two pointers to hold
     // the addresses of a and b
    int *p = &a, *q = &b

    NSLog(@"Before Swapping");
    NSLog(@"Value of a = %d", a);
    NSLog(@"Value of b = %d", b);
    
    // Call the swap function, passing 
    // the addresses of p and q
    swap(&p, &q); 
    
    NSLog(@"\nAfter Swapping");
    NSLog(@"Value of a = %d", *p);
    NSLog(@"Value of b = %d", *q);
    [pool drain];
    return 0;
}

Output:

Before Swapping
Value of a = 10
Value of b = 20
After Swapping
Value of a = 20
Value of b = 10

Example 2: Using pointer to pointer to dynamically allocate memory. 

// Objective-C Program to illustrate pointer
// to pointer to dynamically allocate memory. 
#import <Foundation/Foundation.h>

int main() 
{
    // Integer variable
    int i = 5; 
    
    // Pointer to an integer
    int *p; 
    
    // Pointer to a pointer to an integer
    int **q; 
    
    // Store the address of i in p
    p = &i 
    
    // Store the address of p in q
    q = &p 
    
    NSLog(@"Value stored at i = %d", i);
    NSLog(@"Value stored at *p = %d", *p);
    NSLog(@"Value stored at **q = %d", **q);
    
    return 0;
}

Output:

Value stored at i = 5
Value stored at *p = 5
Value stored at **q = 5