Void pointer in C++ | Basics of C++ - Software Development PDF Download

Introduction

C++ is a powerful programming language that provides a wide range of features to developers. One such feature is the use of void pointers. Void pointers, also known as generic pointers, are pointers that can point to any data type in C++. In this article, we will explain what void pointers are, how they work, and how to use them in your programs.

What is a Void Pointer?

In C++, a void pointer is a pointer that has no associated data type. It is a generic pointer that can be used to point to any type of data. This means that you can use a void pointer to point to an int, a float, a double, a char, or any other data type in C++. The syntax for declaring a void pointer is as follows:

'void* ptr;'

This creates a void pointer called ptr that can point to any type of data. Note that when you declare a void pointer, you cannot dereference it directly, as there is no associated data type.

Using Void Pointers

In order to use a void pointer, you must first cast it to the appropriate type. For example, if you have a void pointer that points to an integer, you can cast it to an int pointer using the following syntax:

int* ptr = (int*) void_ptr;

This creates an int pointer called ptr that points to the same memory location as void_ptr. Note that you must cast the void pointer to the appropriate type before dereferencing it, as void pointers cannot be dereferenced directly.

Example:

#include <iostream>

using namespace std;

int main() {

   int i = 5;

   void* ptr = &i;

   int* int_ptr = static_cast<int*>(ptr);

   cout << *int_ptr << endl;

   return 0;

}

Output

5

In the above example, we declare an integer i and create a void pointer ptr that points to its memory location. We then cast ptr to an int pointer using static_cast and dereference it to get the value of i.

Void Pointers and Dynamic Memory Allocation

Void pointers are often used in conjunction with dynamic memory allocation. When you allocate memory dynamically using new or malloc, the pointer returned is a void pointer. You must cast this pointer to the appropriate type before dereferencing it.
Example:

#include <iostream>

using namespace std;

int main() {

   int* ptr = new int;

   *ptr = 10;

   void* void_ptr = ptr;

   int* int_ptr = static_cast<int*>(void_ptr);

   cout << *int_ptr << endl;

   delete ptr;

   return 0;

}

Output

10

In the above example, we dynamically allocate an integer using new and store the pointer in ptr. We then set the value of the integer to 10 and create a void pointer void_ptr that points to the same memory location as ptr. We cast void_ptr to an int pointer and dereference it to get the value of the integer.

Sample Problems

1. Write a program that uses a void pointer to print out the contents of an array of integers.

#include <iostream>

using namespace std;

int main() {

   int arr[5] = {1, 2, 3, 4, 5};

   void* void_ptr = arr;

  int* int_ptr = static_cast<int*>(void_ptr);

   for(int i = 0; i < 5; i++) {

      cout << int_ptr[i] << " ";

   }

   cout << endl;

   return 0;

}

Output

1 2 3 4 5

2. Write a program that uses a void pointer to swap the values of two integers.

#include <iostream>

using namespace std;

void swap(void* a, void* b) {

   void* temp = a;

   a = b;

   b = temp;

}

int main() {

   int x = 5, y = 10;

   void* ptr1 = &x;

   void* ptr2 = &y;

   swap(ptr1, ptr2);

   cout << "x = " << x << endl;

   cout << "y = " << y << endl;

   return 0;

}

Output

x = 5

y = 10

In the above example, we define a function called swap that takes two void pointers as arguments. We then create two integer variables x and y, and create void pointers ptr1 and ptr2 that point to their memory locations. We pass ptr1 and ptr2 to the swap function, which swaps the values of x and y. However, since we passed void pointers to the function, the swap does not work as intended, as we are only swapping the memory locations of x and y, rather than their values.

Conclusion

Void pointers are a powerful feature of C++ that allow you to create generic pointers that can point to any type of data. They are often used in conjunction with dynamic memory allocation to allocate memory for any type of data. Remember that when you use void pointers, you must cast them to the appropriate type before dereferencing them.