Application Of Pointer in C++
Pointers are one of the most powerful tools of the C++ programming language. They are used for a wide number of purposes some of which are given below:
1. Passing Arguments by Reference
Pointers in C++ are commonly used to pass arguments by reference to functions. By passing the variables by reference we can modify the actual value of the variable passed to the function, rather than working with a copy of the value.
Example
The below example demonstrates the use of a pointer to change the local values of one function in another.
C++
// C++ program to demonstrate the use of pointer to change // local values of one function in another. #include <iostream> using namespace std; // Function to modify the value of an integer using a // pointer void modifyValue( int * ptr) { // Dereferencing the pointer to access and modify the // actual value (*ptr) += 5; } int main() { // Declaring and initializing an integer variable int x = 10; // Displaying the original value cout << "Original value is: " << x << endl; // Passing the address of the variable to the function modifyValue(&x); // Displaying the modified value cout << "Modified value is: " << x << endl; return 0; } |
Original value is: 10 Modified value is: 15
2. For Dynamic Memory Allocation
In C++, dynamic memory allocation is very important application of pointer that allows programs to request and manage memory during runtime. The new keyword is used to allocate the dynamic memory, and it returns a pointer to allocate memory. To deallocate memory, the delete keyword is used with pointers pointing to dynamically allocated memory.
Example
The below example illustrates the use of pointers in dynamic memory allocation.
C++
#include <iostream> using namespace std; int main() { // Dynamic memory allocation for an integer int * Int = new int ; // Store a value in the dynamically allocated memory *Int = 42; // Display the value stored in the dynamically allocated // memory cout << "Value stored in dynamically allocated memory: " << *Int << endl; // Deallocate the dynamically allocated memory to avoid // memory leaks delete Int; // Dynamic memory allocation for an array of integers int * Arr = new int [5]; // Store values in the dynamically allocated array for ( int i = 0; i < 5; ++i) { Arr[i] = i + 1; } // Display the values stored in the dynamically // allocated array cout << "Values stored in dynamically allocated array: " ; for ( int i = 0; i < 5; ++i) { cout << Arr[i] << " " ; } cout << endl; // Deallocate the dynamically allocated array delete [] Arr; return 0; } |
Value stored in dynamically allocated memory: 42 Values stored in dynamically allocated array: 1 2 3 4 5
3. To Access Array Elements
The way there can be an array of integers or an array of floats, similarly there can be an array of pointers. Since a pointer variable always contains an address, an array of pointers would be nothing but a collection of addresses. The addresses present in the array of pointers can be addresses of isolated variables addresses of array elements or any other addresses that can be used to access array elements to print or perform operations on them. Internally the compiler uses pointers to access array elements.
Example
The below example demonstrates that the compiler internally uses pointer arithmetic to access array elements.
C++
//// C++ program to demonstrate that compiler // internally uses pointer arithmetic to access // array elements. #include <iostream> using namespace std; int main() { // Declare an array of integers int arr[5] = { 1, 2, 3, 4, 5 }; // Declare a pointer and point it to the first element // of the array int * ptr = arr; // Access array elements using pointers cout << "Value at arr[0]: " << *ptr << endl; // Using pointer to access other elements for ( int i = 1; i < 5; ++i) { cout << "Value at arr[" << i << "]: " << *(ptr + i) << endl; } return 0; } |
Value at arr[0]: 1 Value at arr[1]: 2 Value at arr[2]: 3 Value at arr[3]: 4 Value at arr[4]: 5
4. To Return Multiple Values
Pointers in C++ are used to return multiple values from a function. We can achieve this by passing memory addresses (or pointers) to the function, and then the modification of values can be done by the function at those addresses.
Example
C++
// C++ program to return multiple values from function using // pointers #include <iostream> using namespace std; // Function that returns multiple values using pointers void getValues( int x, int y, int * sum, int * prod) { // Calculating sum and product and storing them at the // provided addresses *sum = x + y; *prod = x * y; } int main() { // Declaring the variables to store the results int resSum, resProd; // Calling the function and passing addresses of // variables to store results getValues(3, 4, &resSum, &resProd); // Displayinf the results cout << "Sum is: " << resSum << endl; cout << "Product is: " << resProd << endl; return 0; } |
Sum is: 7 Product is: 12
5. Creating Different Data Structures
Different data structures from arrays and linked lists to graphs and trees are implemented using pointers in C++. The following example demonstrates how to implement linked lists using pointers
Example
The below example demonstrates the use of pointer to dynamically allocate memory for structure.
C++
// C++ program to demonstrate linked list operations #include <iostream> using namespace std; // Node class to represent a node of the linked list. class Node { public : int data; Node* next; // Default constructor Node() { data = 0; next = NULL; } // Parameterised Constructor Node( int data) { this ->data = data; this ->next = NULL; } }; // LinkedList class to implement a linked list. class LinkedList { Node* head; public : // Default constructor LinkedList() { head = NULL; } // Function to insert a node at the end of the linked // list. void insertNode( int data) { // Create the new Node. Node* newNode = new Node(data); // If list is empty, assign newNode to head if (head == NULL) { head = newNode; return ; } // Traverse till end of list Node* temp = head; while (temp->next != NULL) { // Move to next node temp = temp->next; } // Insert newNode at the end. temp->next = newNode; } // Function to print the linked list. void printList() { Node* temp = head; // Check for empty list. if (head == NULL) { cout << "List empty" << endl; return ; } // Traverse the list and print each node's data. while (temp != NULL) { cout << temp->data << " " ; temp = temp->next; } } }; // Driver Code int main() { LinkedList list; // Inserting nodes list.insertNode(1); list.insertNode(2); list.insertNode(3); list.insertNode(4); cout << "Elements of the list are: " ; // Print the list list.printList(); cout << endl; return 0; } |
Elements of the list are: 1 2 3 4
6. Achieving Runtime Polymorphism
Function pointers are used to achieve runtime polymorphism in C++. We generally create a pointer to the base class and based on the object it is pointing to, it finds the function to be executed. Not only that, pointers are used by the compiler to keep the track of virtual functions in the class.
Example
The below example demonstrates the use of function pointers.
C++
// C++ Program to demonstrate the Virtual Function #include <iostream> using namespace std; // Base class class Base { public : // virtual function virtual void display() { cout << "Base display\n" ; } void print() { cout << "Base print\n" ; } }; // Child class class Child : public Base { public : void display() override { cout << "Child display\n" ; } void print() { cout << "Child print\n" ; } }; // Driver code int main() { // Create a pointer of type Base Base* basePtr; // Point basePtr to an object of type Child Child childObj; basePtr = &childObj; // Call the virtual function basePtr->display(); // Call the non-virtual function basePtr->print(); } |
Child display Base print
Application of Pointer in C++
A pointer is a variable that stores the memory address as its value. It points to the location in the computer’s memory where the actual data is stored. Pointer is one of the core features of the C++ programming language which enables various functions like dynamic memory allocation, pass-by-reference, etc.
In this article, we will look at some major applications of pointers in C++.
Syntax of Pointers
We can simply declare a pointer of any type by using a * as a prefix as shown:
dataType *pointerName = &variableName;
To Know more refer to C++ Pointers