C Notes
HubApplications of C Programming LanguageFeatures of C Programming LanguageHistory of C Programming LanguageWhat is C Language?Why Learn C Programming in 2024?First C Program - Hello World in C with ExplanationGCC Compiler - Complete Guide to GNU C CompilerInstall C Compiler on Linux - GCC Setup Guide for All DistrosInstall C Compiler on macOS - Xcode Command Line Tools and Homebrew GCCInstall C Compiler on Windows - MinGW, MSYS2, and WSL GuideSetup VS Code for C Programming - Complete Configuration GuideC Syntax Rules — Complete GuideComments in C ProgrammingConstants in C ProgrammingData Types in CIdentifiers in C ProgrammingKeywords in C ProgrammingStructure of a C ProgramVariables in C ProgrammingArithmetic Operators in C ProgrammingAssignment Operators in C ProgrammingBitwise Operators in C ProgrammingIncrement and Decrement Operators in CLogical Operators in C ProgrammingRelational Operators in C ProgrammingTernary Operator in C ProgrammingBreak Statement in C ProgrammingContinue Statement in C ProgrammingDo-While Loop in C ProgrammingFor Loop in C ProgrammingGoto Statement in C Programmingif-else Statement in C Programmingif Statement in C ProgrammingNested if Statements in C ProgrammingSwitch Statement in C ProgrammingWhile Loop in C ProgrammingFunction Arguments in C - Pass by Value vs Pass by ReferenceFunction Call in C ProgrammingFunction Declaration (Prototype) in CFunction Definition in C ProgrammingIntroduction to Functions in C ProgrammingRecursion in C ProgrammingReturn Statement in C ProgrammingStorage Classes in C ProgrammingArray Operations in C - Searching, Sorting, Insert and DeleteArray Programs in C - Reverse, Rotate, Duplicates, MergeIntroduction to Arrays in C ProgrammingMultidimensional Arrays in C ProgrammingOne Dimensional Arrays in C ProgrammingPassing Arrays to Functions in CTwo Dimensional Arrays in C ProgrammingString Comparison in C - strcmp, strncmp, Case-InsensitiveString Functions in C - strlen, strcpy, strcat, strcmpC String Handling Library - Complete string.h ReferenceString Manipulation in C - Reverse, Uppercase, PalindromeString Programs in C - Anagram, Word Count, Vowels, FrequencyStrings in C Programming - Complete IntroductionDouble Pointers in C - Pointer to PointerPointer Arithmetic in C ProgrammingPointer Declaration and Initialization in CPointer Programs in C - Swap, String Reversal, Dynamic AllocationPointers and Arrays in C - The Relationship ExplainedPointers and Functions in C - Pass by ReferenceIntroduction to Pointers in C ProgrammingVoid Pointers in C - Generic Pointers Guidecalloc() in C – Contiguous Memory AllocationDynamic Arrays in C – Runtime-Sized Arraysfree() in C – Releasing Dynamic Memorymalloc() in C – Dynamic Memory AllocationMemory Management Best Practices in Crealloc() in C – Resizing Dynamic MemoryBinary Files in C – fread and fwriteFile Handling in C – IntroductionFile Handling Projects in C – Student Records & Phone BookFile Modes in C – Complete Guidefopen() and fclose() in C – Opening and Closing FilesReading Files in C – fgetc, fgets, fscanf, freadWriting Files in C – fputc, fputs, fprintf, fwriteConditional Compilation in C – #ifdef, #ifndef, #if#define Macros in C – Constants and Macro FunctionsHeader Files in C – Creating Custom Headers#include Directive in C – File InclusionMacro Functions in C – Parameterized MacrosC Preprocessor – Overview and DirectivesGraphs in C – Adjacency Matrix, Adjacency List, BFS, and DFSHash Tables in C – Implementation, Collision Handling, and ChainingLinked List in C – Singly, Doubly, and Circular with ImplementationQueue in C – Linear, Circular, and Priority Queue ImplementationStack in C – Array and Linked List Implementation with ApplicationsTrees in C – Binary Search Tree Implementation with TraversalsC Programming Best Practices – Coding Standards, Safety, and PerformanceBit Fields in C – Definition, Use Cases, and Protocol HeadersC Standard Library Overview – All Headers and Common FunctionsCommand Line Arguments in C – argc and argv ExplainedDebugging Techniques in C – GDB, Valgrind, and SanitizersFunction Pointers in C – Complete Guide with ExamplesMemory Layout of a C Program – Text, Data, BSS, Heap, StackBank Management System in C – Complete Project with File StorageFile Encryption Tool in C – XOR Cipher ImplementationLibrary Management System in C – Complete Project with Source CodeMini Compiler in C – Lexer and Parser for Simple ExpressionsSnake Game in C – Console-Based Game with Source CodeStudent Management System in C – Complete Project with Source CodeC Programming Cheatsheet – Complete Quick Reference GuideTop 50 C Programming Interview Questions with Answers (2025)Memory Management Interview Questions in C with AnswersOutput Prediction Questions in C – What Will This Program Print?Pointer Interview Questions in C – Tricky Problems with AnswersCommon C Programming Errors and Solutions – Debugging GuideImportant C Programs – 50+ Frequently Asked Programs with SolutionsQuick Revision Notes for C Programming – Complete C in 10 MinutesRecommended C Programming Books – From Beginner to ExpertFormat Specifiers in C - Complete Referencegetchar() and putchar() in C Programminggets() and puts() in C ProgrammingC Input Output Programs and Examplesprintf() Function in C Programmingscanf() Function in C ProgrammingArrays of Structures in C – Managing CollectionsEnums in C – Enumerated Data TypesNested Structures in C – Struct Within StructPointers to Structures in C – Arrow OperatorStructures in C – User-Defined Data Typestypedef in C – Creating Type AliasesUnions in C – Shared Memory Data Types
Learn about void pointers (generic pointers) in C including declaration, type casting, use cases in generic functions, and limitations with practical examples.
A void pointer (void *) is a special type of pointer that can point to any data type. It's C's version of a generic or universal pointer — you can store the address of an int, float, char, struct, or any other type in a void * variable. However, since the compiler doesn't know what type the pointer refers to, you must explicitly cast it before dereferencing.
Void pointers are the foundation of generic programming in C, used extensively in standard library functions like malloc, qsort, memcpy, and bsearch.
Declaration and Basic Usage
c example
#include <stdio.h>
int main() {
int x = 42;
float f = 3.14;
char c = 'A';
void *vptr; // Can point to anything
// Point to int
vptr = &x;
printf("As int: %d\n", *(int *)vptr); // Must cast before dereferencing
// Point to float
vptr = &f;
printf("As float: %.2f\n", *(float *)vptr);
// Point to char
vptr = &c;
printf("As char: %c\n", *(char *)vptr);
return 0;
}Output
As int: 42 As float: 3.14 As char: A
Why Can't You Dereference a Void Pointer Directly?
The compiler needs to know the data type to:
- Determine how many bytes to read/write
- Interpret the bit pattern correctly
Example
void *vptr = &x;
// *vptr = 10; // ERROR: void* cannot be dereferenced
// vptr++; // ERROR: cannot do arithmetic (unknown size)
*(int *)vptr = 10; // OK: cast tells compiler "read 4 bytes as int"
| As (int *): reads 4 bytes | 0x0000002A → 42 |
| As (float *): reads 4 bytes | interprets as float |
| As (char *): reads 1 byte | 0x2A → '*' |
| As (double *): reads 8 bytes | completely different value |
Void Pointers in Memory Allocation
malloc returns void * because it doesn't know what type you'll store:
Example
#include <stdio.h>
#include <stdlib.h>
int main() {
// malloc returns void* — compatible with any pointer type
int *arr = (int *)malloc(5 * sizeof(int));
if (arr == NULL) {
printf("Allocation failed!\n");
return 1;
}
for (int i = 0; i < 5; i++) {
arr[i] = (i + 1) * 10;
}
for (int i = 0; i < 5; i++) {
printf("%d ", arr[i]);
}
printf("\n");
free(arr); // free also takes void*
return 0;
}
Output
10 20 30 40 50
Note: In C, casting the return value of malloc is optional (void* implicitly converts to any pointer type). In C++, the cast is required.Writing Generic Functions with Void Pointers
Generic Swap Function
Example
#include <stdio.h>
#include <string.h>
void genericSwap(void *a, void *b, size_t size) {
char temp[size]; // Temporary buffer
memcpy(temp, a, size);
memcpy(a, b, size);
memcpy(b, temp, size);
}
int main() {
// Swap integers
int x = 10, y = 20;
printf("Before: x=%d, y=%d\n", x, y);
genericSwap(&x, &y, sizeof(int));
printf("After: x=%d, y=%d\n", x, y);
// Swap floats
float a = 1.5, b = 2.7;
printf("\nBefore: a=%.1f, b=%.1f\n", a, b);
genericSwap(&a, &b, sizeof(float));
printf("After: a=%.1f, b=%.1f\n", a, b);
// Swap strings (char arrays)
char s1[20] = "Hello";
char s2[20] = "World";
printf("\nBefore: s1=%s, s2=%s\n", s1, s2);
genericSwap(s1, s2, 20);
printf("After: s1=%s, s2=%s\n", s1, s2);
return 0;
}
Output
Before: x=10, y=20 After: x=20, y=10 Before: a=1.5, b=2.7 After: a=2.7, b=1.5 Before: s1=Hello, s2=World After: s1=World, s2=Hello
Generic Print Function
Example
#include <stdio.h>
typedef enum { INT, FLOAT, CHAR, STRING } DataType;
void genericPrint(void *data, DataType type) {
switch (type) {
case INT:
printf("%d", *(int *)data);
break;
case FLOAT:
printf("%.2f", *(float *)data);
break;
case CHAR:
printf("%c", *(char *)data);
break;
case STRING:
printf("%s", (char *)data);
break;
}
printf("\n");
}
int main() {
int n = 42;
float f = 3.14;
char c = 'Z';
char str[] = "Hello";
genericPrint(&n, INT);
genericPrint(&f, FLOAT);
genericPrint(&c, CHAR);
genericPrint(str, STRING);
return 0;
}
Output
42 3.14 Z Hello
Generic Array Search
Example
#include <stdio.h>
#include <string.h>
int genericSearch(void *arr, int count, size_t elemSize,
void *target, int (*compare)(const void *, const void *)) {
for (int i = 0; i < count; i++) {
void *elem = (char *)arr + i * elemSize;
if (compare(elem, target) == 0) {
return i;
}
}
return -1;
}
int compareInt(const void *a, const void *b) {
return *(int *)a - *(int *)b;
}
int compareFloat(const void *a, const void *b) {
float diff = *(float *)a - *(float *)b;
return (diff > 0) - (diff < 0);
}
int main() {
int arr[] = {10, 20, 30, 40, 50};
int target = 30;
int idx = genericSearch(arr, 5, sizeof(int), &target, compareInt);
printf("Found %d at index %d\n", target, idx);
float farr[] = {1.1, 2.2, 3.3, 4.4};
float ftarget = 3.3;
idx = genericSearch(farr, 4, sizeof(float), &ftarget, compareFloat);
printf("Found %.1f at index %d\n", ftarget, idx);
return 0;
}
Output
Found 30 at index 2 Found 3.3 at index 2
Void Pointer Arithmetic
Standard C does not allow arithmetic on void pointers (since the compiler doesn't know the element size). However, GCC allows it as an extension, treating void * like char *:
c example
#include <stdio.h>
int main() {
int arr[] = {10, 20, 30, 40};
void *vptr = arr;
// Standard way: cast to char* for byte-level arithmetic
int *second = (int *)((char *)vptr + sizeof(int));
printf("Second element: %d\n", *second);
// GCC extension (non-portable):
// int *third = (int *)(vptr + 2 * sizeof(int));
return 0;
}Output
Second element: 20
Void Pointer Rules and Limitations
| Feature | Allowed? | Notes |
|---|---|---|
| Assign any pointer to void* | ✅ Yes | Implicit conversion |
| Assign void* to typed pointer | ✅ In C | Implicit in C, explicit cast in C++ |
| Dereference void* | ❌ No | Must cast first |
| Pointer arithmetic | ❌ No | Undefined size; cast to char* first |
| Compare void* pointers | ✅ Yes | ==, != work fine |
| sizeof(void) | ❌ Undefined | GCC gives 1 (extension) |
| void* as function parameter | ✅ Yes | Basis of generic functions |
Practical Use: Implementing a Generic Stack
Example
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct {
void *data;
size_t elemSize;
int top;
int capacity;
} GenericStack;
GenericStack* createStack(int capacity, size_t elemSize) {
GenericStack *s = (GenericStack *)malloc(sizeof(GenericStack));
s->data = malloc(capacity * elemSize);
s->elemSize = elemSize;
s->top = -1;
s->capacity = capacity;
return s;
}
void push(GenericStack *s, void *element) {
if (s->top >= s->capacity - 1) return;
s->top++;
void *target = (char *)s->data + s->top * s->elemSize;
memcpy(target, element, s->elemSize);
}
void pop(GenericStack *s, void *result) {
if (s->top < 0) return;
void *source = (char *)s->data + s->top * s->elemSize;
memcpy(result, source, s->elemSize);
s->top--;
}
int main() {
// Integer stack
GenericStack *intStack = createStack(10, sizeof(int));
int vals[] = {10, 20, 30};
for (int i = 0; i < 3; i++) push(intStack, &vals[i]);
printf("Popping: ");
int val;
while (intStack->top >= 0) {
pop(intStack, &val);
printf("%d ", val);
}
printf("\n");
free(intStack->data);
free(intStack);
return 0;
}
Output
Popping: 30 20 10
Interview Questions
**Q1: Why does malloc return void* instead of a specific type?**
Because malloc allocates raw memory without knowing how it will be used. Returning void* makes it compatible with any pointer type — the caller decides how to interpret the allocated memory by casting (explicitly or implicitly in C).
Q2: What's the difference between NULL and void pointer?
NULL is a value (typically 0) that represents "points to nothing." A void pointer is a type (void *) that can point to any data type. A void pointer can be NULL or can hold a valid address — they're orthogonal concepts.
Q3: Can you do pointer arithmetic on void pointers in standard C?
No. The C standard does not allow arithmetic on void * because the compiler doesn't know the element size. You must cast to a typed pointer (typically char * for byte-level operations) first. GCC allows it as a non-standard extension.
Q4: How does qsort use void pointers for generic sorting?
qsort takes void *base (the array), size_t nmemb (element count), size_t size (element size), and a comparison function. It manipulates the array using byte-level operations (memcpy with the size parameter) and delegates type-specific comparison to the callback function.
Summary
void *is a generic pointer that can hold the address of any type- You must cast a void pointer before dereferencing it
- Pointer arithmetic is not allowed on void pointers in standard C
malloc,calloc,free,memcpy,qsortall use void pointers for genericity- Pass
size_talongside void pointers so functions know element sizes - Void pointers enable generic data structures and algorithms in C
- In C (unlike C++), void pointers implicitly convert to/from any pointer type
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Void Pointers in C - Generic Pointers Guide.
Interview Use
Prepare one clear explanation, one practical example, and one common mistake for this C Programming topic.
Search Terms
c-programming, c programming, programming, pointers, void, void pointers in c - generic pointers guide
Related C Programming Topics
Continue learning this concept
PointersDouble Pointers in C - Pointer to PointerMaster double pointers (pointer to pointer) in C including declaration, usage with functions, dynamic 2D arrays, and practical applications with memory diagrams.PointersPointer Arithmetic in C ProgrammingLearn pointer arithmetic in C including increment, decrement, addition, subtraction, pointer difference, and comparison with detailed memory diagrams and examples.PointersPointer Declaration and Initialization in CLearn how to declare and initialize pointers in C using * and & operators, pointer types, multiple pointer declarations, and const pointers with examples.PointersPointer Programs in C - Swap, String Reversal, Dynamic AllocationPractice essential pointer programs in C including swap using pointers, string operations with pointers, dynamic memory allocation, and pointer-based data manipulation.PointersPointers and Arrays in C - The Relationship ExplainedUnderstand the deep connection between pointers and arrays in C, array name as pointer, pointer-based array access, and key differences with practical examples.PointersPointers and Functions in C - Pass by ReferenceLearn how to use pointers with functions in C for pass-by-reference, returning pointers, function pointers, and callback patterns with practical examples.