Program 1: Using a Void Pointer with an Integer Variable

The following program demonstrates how a void pointer can store the address of an integer variable. Since a void pointer has no associated data type, it must be typecast to an int * before accessing or modifying the value.

void main()
{
    void *ptr;
    int num;
    ptr = #
    *(int*)ptr = 23;
    printf("Value : %d ", num);
    printf("Value : %d", *(int*)ptr);
}

Output

Value : 23
Value : 23

Program 2: Using a Void Pointer with a Float Variable

The following example shows that a void pointer can also store the address of a floating-point variable. Before accessing the value, the pointer must be converted to a float *.

void main()
{
    void *ptr;
    float num;
    ptr = #
    *(float*)ptr = 65.87;
    printf("Value : %.2f ", num);
    printf("Value : %.2f", *(float*)ptr);
}

Output

Value : 65.87
Value : 65.87

Why Do We Use Void Pointers?

A void pointer provides flexibility because it is not restricted to a particular data type. It can be reused with different types of variables, making programs more generic and reusable.

Some of the major uses of void pointers are listed below.

• They can store the address of variables belonging to any data type.
• A single pointer variable can be reused for multiple data types, reducing the need for separate pointer variables.
• Dynamic Memory Allocation (DMA) functions such as malloc() and calloc() return a void * pointer.
• They are widely used for creating generic functions that can process different types of data.
• They improve code reusability by allowing the same function to work with multiple data types.

Program 3: Generic Function Using a Void Pointer

One of the biggest advantages of a void pointer is that it allows us to create generic functions. A generic function can work with multiple data types instead of being limited to a single type.

In the following program, the function printValue() accepts a void * pointer along with a character that specifies the data type. Based on the supplied type, the function converts the void pointer to the appropriate pointer type and prints the corresponding value.

// GENERIC FUNCTION USING VOID POINTER
void printValue(void *, char);
void main()
{
    int a = 33;
    float b = 69.14;
    char h = 'P';
    printValue(&a, 'i');
    printValue(&b, 'f');
    printValue(&h, 'c');
}
void printValue(void *ptr, char type)
{
    switch(type)
    {
        case 'c':
            printf("Character Value : %c ", *(char*)ptr);
            break;
        case 'i':
            printf("Integer Value : %d ", *(int*)ptr);
            break;
        case 'f':
            printf("Float Value : %.2f ", *(float*)ptr);
            break;
        default:
            printf("Sorry | Invalid Type.");
    }
}

Output

Integer Value : 33
Float Value : 69.14
Character Value : P

Type Casting Rules for Void Pointers in C and C++

The rules for assigning and converting void pointers are slightly different in C and C++. Understanding these differences is important for both competitive examinations and interviews.

// Myfile.c
void main()
{
    int num = 33;
    int *ptr1, *ptr2;
    void *ptr3;
    ptr1 = #
    ptr3 = ptr1;      // T* ? void* (Implicit)
    ptr2 = ptr3;      // void* ? T* (Implicit)
    printf("Value : %d ", num);
    printf("Value : %d ", *ptr1);
    printf("Value : %d ", *ptr2);
    printf("Value : %d ", *(int*)ptr3);
}

Value : 33
Value : 33
Value : 33
Value : 33

// Myfile.cpp
int main()
{
    int num = 33;
    int *ptr1, *ptr2;
    void *ptr3;
    ptr1 = #
    ptr3 = ptr1;      // T* ? void* (Implicit)
    // ptr2 = ptr3;   // Error (Implicit conversion is not allowed)
    ptr2 = (int*)ptr3;    // Explicit typecasting
    printf("Value : %d ", num);
    printf("Value : %d ", *ptr1);
    printf("Value : %d ", *ptr2);
    printf("Value : %d ", *(int*)ptr3);
    return 0;
}

Value : 33
Value : 33
Value : 33
Value : 33