Example 1: Basic Pointers
#include
#include
int main() {
// Normal Variable
int var = 10;
// Pointer Variable ptr that
// stores address of var
int* ptr = &var;
// Directly accessing ptr will
// give us an address
// This dereferences the pointer
printf("%d", *ptr);
return 0;
}
//here is the output without the '&' : 0x7fff67b3056c
Example 2: Sizeof Pointers
#include
int main() {
int *ptr1;
char *ptr2;
// Finding size using sizeof()
printf("%zu\n", sizeof(ptr1)); //zu is used specifically for sizeof outputs
printf("%zu", sizeof(ptr2));
return 0;
}
Example 3: Null Pointers
/* Null pointers are those pointers that do not point to any memory location. They can be
created by assigning NULL value to a pointer. A pointer of any type can be assigned the
NULL value.
Null pointers are generally used to represent the absence of any address. This allows
us to check whether the pointer is pointing to any valid memory location by checking
if it is equal to NULL. */
#include
int main() {
// Null pointer
int *ptr = NULL;
return 0;
}
Example 4: Void Pointers
/* The void pointers in C are the pointers of type void. It means that they do not have
any associated data type. They are also called generic pointers as they can point to
any type and can be typecasted to any type. */
#include
int main() {
// Void pointer
void *ptr;
return 0;
}
Example 5: Wild Pointers
/* The wild pointers are pointers that have not been initialized with something yet.
These types of C-pointers can cause problems in our programs and can eventually
cause them to crash. If values are updated using wild pointers, they could cause
data abort or data corruption. */
int main() {
// Wild Pointer
int *ptr;
return 0;
}
Example 6: Dangling Pointers
/* A pointer pointing to a memory location that has been deleted (or freed) is called a dangling pointer.
Such a situation can lead to unexpected behavior in the program and also serve as a source of bugs in C programs. */
#include
#include
int main() {
// malloc asks the heap to give you enough memory to store one integer
int* ptr = (int*)malloc(sizeof(int));
// Here we can print the address of the un-initialized pointer, since it is a
// generic pointer it expects "void*"
printf("%p\n", (void*)ptr);
// After below free call, ptr becomes a dangling pointer
free(ptr);
printf("Memory freed\n");
// removing Dangling Pointer
ptr = NULL;
return 0;
}
Example 7: Constant Pointers
/* In constant pointers, the memory address stored inside the pointer is constant
and cannot be modified once it is defined. It will always point to the same memory
address. */
#include
int main() {
int a = 90;
int b = 50;
// Creating a constant pointer
int* const ptr = &a;
// Trying to reassign it to b
ptr = &b;
return 0;
}
// OUTPUT
solution.c: In function ‘main’:
solution.c:11:9: error: assignment of read-only variable ‘ptr’
11 | ptr = &b;
|
Example 8: Function Pointer
/* A function pointer is a type of pointer that stores the address of a function,
allowing functions to be passed as arguments and invoked dynamically. It is useful
in techniques such as callback functions, event-driven programs. */
#include
int add(int a, int b) {
return a + b;
}
int main() {
// Declare a function pointer that matches
// the signature of add() fuction
int (*fptr)(int, int);
// Assign address of add()
fptr = &add;
// Call the function via ptr
printf("%d", fptr(10, 5));
return 0;
}
// OUTPUT : 15
Example 9: Multilevel Pointers
/* In C, we can create multi-level pointers with any number of levels such as – ***ptr3,
****ptr4, ******ptr5 and so on. Most popular of them is double pointer
(pointer to pointer). It stores the memory address of another pointer.
Instead of pointing to a data value, they point to another pointer. */
#include
int main() {
int var = 10;
// Pointer to int
int *ptr1 = &var;
// Pointer to pointer (double pointer)
int **ptr2 = &ptr1;
// Accessing values using all three
printf("var: %d\n", var);
printf("*ptr1: %d\n", *ptr1);
printf("**ptr2: %d", **ptr2);
return 0;
}
// OUTPUT
var: 10
*ptr1: 10
**ptr2: 10
Example 10a: Pointers with Arrays - Part 1
#include
int main() {
int arr[5] = {10, 20, 30, 40, 50};
// Pointer to the first element of the array
int* ptr = arr; // same as &arr[0]
// Access elements using pointer arithmetic
printf("First element: %d\n", *ptr); // 10
printf("Second element: %d\n", *(ptr + 1)); // 20
printf("Third element: %d\n", *(ptr + 2)); // 30
// You can also use the pointer like an array
printf("Fourth element: %d\n", ptr[3]); // 40
printf("Fifth element: %d\n", ptr[4]); // 50
return 0;
}
Example 10b: Pointers with Arrays - Part 2
#include
int main() {
int arr[5] = {10, 20, 30, 40, 50};
int* ptr = arr; // points to arr[0]
// Increment pointer (move forward)
printf("Start: %d\n", *ptr); // 10
ptr++; // move to arr[1]
printf("After ++ : %d\n", *ptr); // 20
// Decrement pointer (move backward)
ptr--; // back to arr[0]
printf("After -- : %d\n", *ptr); // 10
// Add an offset
ptr = ptr + 3; // move to arr[3]
printf("ptr + 3: %d\n", *ptr); // 40
// Subtract an offset
ptr = ptr - 2; // back to arr[1]
printf("ptr - 2: %d\n", *ptr); // 20
return 0;
}
