# What Is Double Pointer in Data Structure?

//

Larry Thompson

A double pointer is a concept that is used in data structures, particularly in programming languages like C and C++. It is a powerful tool that allows programmers to manipulate and access data in an efficient manner. In this article, we will explore what double pointers are, how they work, and why they are important in the field of data structures.

## What is a Pointer?

Before diving into the concept of double pointers, let’s quickly recap what a pointer is. In simple terms, a pointer is a variable that stores the memory address of another variable. It allows us to indirectly access and modify the value of that variable.

Example:

```int num = 10;
int *ptr = #
```

In the above example, we have declared an integer variable named “num” with a value of 10. We then declare a pointer variable named “ptr” using the asterisk (*) symbol. The ampersand (&) operator is used to assign the memory address of “num” to “ptr”.

## Introducing Double Pointers

A double pointer, also known as a pointer-to-pointer, is a variable that stores the memory address of another pointer. Instead of pointing directly to a value or object, it points to another pointer which in turn points to the desired value or object.

```int num = 10;
int *ptr1 = #
int **ptr2 = &ptr1;
```

In this example, we have declared two pointer variables: “ptr1” and “ptr2”. “ptr1” points directly to the integer variable “num”, while “ptr2” points to the address of “ptr1”. Thus, we have a double indirection, where “ptr2” indirectly points to the value of “num”.

## Why Use Double Pointers?

Double pointers are useful in situations where we need to modify the original pointer itself or pass a pointer by reference to a function. They provide an additional level of indirection and flexibility in handling data structures.

One common use case of double pointers is in dynamic memory allocation. When we allocate memory for arrays or linked lists, the memory addresses are assigned to a pointer. By using a double pointer, we can modify the original pointer and perform operations such as insertion, deletion, or traversal on the data structure.

• Modifying Pointer Variables: With double pointers, we can modify the original pointer variable itself, allowing us to reassign it or reallocate memory if required.
• Passing Pointers by Reference: In some scenarios, passing pointers to functions by reference is necessary. Using double pointers enables us to achieve this and modify the original pointer within the function.
• Dynamically Allocating Memory: Double pointers are commonly used when dynamically allocating memory for complex data structures like linked lists or trees. They allow us to manipulate and traverse the structure efficiently.

## Conclusion

In conclusion, a double pointer is an essential concept in data structures that provides an extra level of indirection for efficient manipulation of data. It allows us to modify original pointers and pass them by reference when needed. Understanding and effectively using double pointers can greatly enhance your programming skills in languages like C and C++.

To summarize:

• A pointer stores the memory address of a variable.
• A double pointer stores the memory address of another pointer.
• Double pointers are useful for modifying pointer variables and passing pointers by reference.
• They are commonly used in dynamic memory allocation and complex data structures.

By grasping the concept of double pointers, you can unlock new possibilities in your programming journey.