Void Pointer in C Language:

The void pointer can hold or store address of any data type. A void pointer is a special type of pointer that is not associated with any data type.

• The void pointer is also known as generic pointer.
• A void pointer cannot be directly dereferenced (must be cast to another pointer type before dereferencing).
• Because the size of a void type is unknown, pointer arithmetic operations are not allowed with a void pointer in standard C (Compile-Time Error: “Size of the type is unknown or zero”). However, in GCC, pointer arithmetic works because it treats void as having a size of 1 byte (non-standard behavior).
• The void pointer must be cast to appropriate data type before dereferencing and performing arithmetic operations. 

If we want to assign a value to the variable num through the pointer ptr, or access num using ptr, we must perform proper type casting, because ptr is a void* and has no type information.
*(int *)ptr = 33;  // assign 33 to num via ptr. *ptr = 33; is error.
Here, the leftmost * is the indirection (dereference) operator — it accesses the value stored at the address and the (int *) part typecasts the void* pointer into an int* pointer before dereferencing.

Program : 1

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

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

This way, by casting void* to the correct type pointer, we can both assign and access values stored in different variable types through the same pointer.

Why Use Void Pointers?

• Void pointers provide flexibility when the exact data type is not known in advance.
• One pointer can be reused for different types without declaring multiple pointer variables.
• The Dynamic Memory Allocation (DMA) functions like malloc() and calloc() return void pointers.
• For generic data handling, writing functions that can accept pointers to any data type.

Program : 3

//GENERIC FUNCTION USING 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

Program : 4

// 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);
}

Output:

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

Program: 5

//Myfile.cpp
int main()
{
    int num=33;
    int *ptr1,*ptr2;
    void *ptr3;
    ptr1=#
    ptr3=ptr1; //T* ? void* (implicit)
    //ptr2=ptr3; Error(Not implicit)
    ptr2=(int*)ptr3; //Explicit cast required
    printf("Value : %d ",num);
    printf("Value : %d ",*ptr1);
    printf("Value : %d ",*ptr2);
    printf("Value : %d ",*(int*)ptr3);
    return 0;
}

Output:

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