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