2026-01-209 min read

pointer types (C Programming)

Learn pointer types (C Programming) step by step with clear examples and exercises.

Why This Matters

Understanding pointer types is crucial for any serious C programmer as they allow direct manipulation of memory, which opens up a world of possibilities for optimizing code and creating complex data structures. Pointers are essential for dynamic memory allocation, function arguments, and returning values from functions. They can help you avoid common bugs and improve performance in your C programs.

Prerequisites

Before diving into pointers, it's important to have a solid understanding of the following concepts:

Variables and data types
Basic arithmetic operations
Control structures (if-else, loops)
Functions and function prototypes
Arrays and array manipulation
File I/O using standard libraries
Understanding the difference between values and memory addresses
Basic understanding of how memory is allocated and deallocated in C

Core Concept

What are pointers?

A pointer is a variable that stores the memory address of another variable or constant. In C, pointers can be used to store addresses of any data type, including integers, floats, characters, and even other pointers. Pointers are declared using the * symbol before the variable name. For example:

int num = 10;
int *ptr; // Declare a pointer to an integer
ptr = &num; // Assign the address of num to ptr

In this example, we declare a variable num and initialize it with the value 10. We then declare a pointer ptr that can store the address of an integer. Finally, we assign the address of num to ptr.

Pointer arithmetic

Pointers in C support basic arithmetic operations like addition and subtraction. When you add or subtract an integer from a pointer, it moves the pointer to the next or previous memory location that has the same data type as the pointer. For example:

int arr[5] = {1, 2, 3, 4, 5};
int *ptr = &arr[0]; // Initialize ptr with the address of the first element in arr

// Move ptr to the second element in arr
ptr++;

printf("%d\n", *ptr); // Output: 2

In this example, we declare an array arr and initialize it with five integers. We then declare a pointer ptr that points to the first element of arr. By incrementing ptr, we move it to the address of the second element in arr. When we dereference ptr (i.e., use the * operator) to access its value, we get the value stored at the new memory location, which is 2.

Pointer dereferencing and assignment

To access the value stored at a memory address pointed to by a pointer, you can use the * operator. For example:

int num = 10;
int *ptr = &num;

printf("%d\n", *ptr); // Output: 10

You can also assign a value to the memory location pointed to by a pointer using the * operator. For example:

int num = 10;
int *ptr = &num;

*ptr = 20; // Assign 20 to the memory location pointed to by ptr
printf("%d\n", num); // Output: 20

Pointers to functions and void pointers

Pointers in C can also be used to store function addresses and void pointers. A pointer to a function is declared by specifying the return type and function arguments within parentheses before the * symbol. For example:

void printNum(int num) {
printf("%d\n", num);
}

void (*funcPtr)(int) = &printNum; // Declare a pointer to a function that takes an integer and returns void
(*funcPtr)(10); // Call the function pointed to by funcPtr with argument 10

A void pointer is declared using the void* type. It can store the address of any data type, but you cannot perform arithmetic operations or dereference it without first casting it to the appropriate data type. For example:

int num = 10;
float fnum = 20.5f;
void *ptr;

ptr = &num; // Store the address of num in ptr
printf("%d\n", *(int *)ptr); // Cast ptr to an integer pointer and dereference it to access its value

ptr = &fnum; // Store the address of fnum in ptr
printf("%f\n", *(float *)ptr); // Cast ptr to a float pointer and dereference it to access its value

Null pointers

In C, a null pointer is represented by the NULL macro or the literal 0. It is used to indicate that a pointer does not point to any valid memory location. For example:

int *ptr = NULL; // Declare a null pointer
if (ptr == NULL) {
printf("ptr is null\n");
}

Worked Example

Let's create a simple program that uses pointers to implement a dynamic array. The program will dynamically allocate memory for an array and allow the user to add elements to it until they choose to exit.

#include <stdio.h>
#include <stdlib.h>

int main() {
int *arr = NULL; // Declare a null pointer that will store the address of our dynamic array
int size = 0; // Initialize the size of our array to 0
int capacity = 1; // Initialize the initial capacity of our array to 1
int num; // Declare a variable to hold user input

printf("Enter a number or type 'q' to quit:\n");

while (scanf("%d", &num) == 1 && num != 'q') {
if (size == capacity) {
capacity *= 2; // Double the capacity of our array when it is full
arr = (int *)realloc(arr, sizeof(int) * capacity); // Reallocate memory for our dynamic array
}

arr[size] = num; // Add the user input to our dynamic array
size++; // Increment the size of our array
printf("Enter a number or type 'q' to quit:\n");
}

printf("The elements in your array are:\n");
for (int i = 0; i < size; i++) {
printf("%d ", arr[i]);
}
printf("\n");

free(arr); // Free the dynamically allocated memory when we're done
return 0;
}

This program uses a pointer arr to store the address of our dynamic array. It starts with an initial capacity of 1 and doubles its capacity whenever it is full. The user can enter numbers until they choose to quit by typing 'q'. When the user enters a number, it is added to the end of the array, which grows dynamically as needed.

Common Mistakes

Forgetting to initialize pointers: Always initialize your pointers to NULL or an appropriate default value before using them.
Dereferencing null pointers: Never dereference a null pointer or assume that it points to valid memory. This can lead to segmentation faults and other runtime errors.
Forgetting the size of arrays when passing them as function arguments: When passing arrays as function arguments, always include their size as an additional argument.
Using pointers incorrectly with printf: Remember that printf requires pointer arguments to be passed using the address-of operator (&) and that it does not automatically increment array pointers.
Confusing pointer arithmetic with regular arithmetic: Pointer arithmetic moves the pointer to the next or previous memory location of the same data type, while regular arithmetic performs standard addition or subtraction on numbers.
Failing to deallocate dynamically allocated memory: Always free dynamically allocated memory when you are done using it to avoid memory leaks.
Using pointers inappropriately for simple tasks: Pointers can make your code more complex and harder to understand, so use them only when necessary and avoid unnecessary pointer usage.
Misunderstanding the difference between pointers and references: In C++, a reference is another name for an existing variable, while a pointer stores the memory address of a variable.
Not handling pointer errors gracefully: Always check for null pointers and handle errors appropriately to prevent your program from crashing unexpectedly.
Forgetting to cast void pointers before dereferencing them: Always cast void pointers to the appropriate data type before dereferencing them to avoid unexpected behavior.

Practice Questions

Write a program that uses pointers to implement a stack data structure. The program should allow the user to push and pop integers onto and off the stack, respectively.
Implement a function void reverse(int *arr, int size) that reverses the order of elements in an integer array using pointers.
Write a program that uses pointers to implement a linked list data structure. The program should allow the user to insert nodes at the beginning and end of the list, as well as delete a node by its value.
Implement a function int max(int *arr, int size) that finds the maximum value in an integer array using pointers.
Write a program that uses pointers to implement a simple text editor. The program should allow the user to read and write lines of text from/to a file.
Implement a function void sort(int *arr, int size) that sorts an integer array in ascending order using pointers and bubble sort algorithm.
Write a program that uses pointers to implement a simple calculator with support for addition, subtraction, multiplication, and division operations.
Implement a function void swap(int *a, int *b) that swaps the values of two integer variables using pointers.
Write a program that uses pointers to implement a simple binary search algorithm on an integer array.
Implement a function char *concatenate(char *str1, char *str2) that concatenates two character strings using pointers and dynamic memory allocation.

FAQ

What happens if I try to dereference a null pointer?

Dereferencing a null pointer can lead to segmentation faults, which are runtime errors that occur when your program tries to access memory it is not allowed to.

How do I check if a pointer points to valid memory?

You can use the NULL macro or the literal 0 to check if a pointer is null. Additionally, you can use the sizeof operator to ensure that a pointer points to valid memory for a given data type.

What is the difference between a regular variable and a pointer variable?

A regular variable stores a value directly, while a pointer variable stores the memory address of another variable or constant.

How do I allocate memory dynamically using pointers in C?

You can use the malloc function to dynamically allocate memory for a variable using a pointer. For example:

int *arr = (int *)malloc(sizeof(int) * size);

How do I free dynamically allocated memory in C?

You can use the free function to deallocate dynamically allocated memory when you are done using it. For example:

free(arr);

What is a dangling pointer?

A dangling pointer is a pointer that points to memory that has been freed or deallocated, but the pointer still holds its old address. Using a dangling pointer can lead to undefined behavior and errors.

How do I avoid using dangling pointers?

To avoid using dangling pointers, always set the pointer to NULL after freeing it or make sure to use it before freeing it. Additionally, be careful when modifying arrays while iterating over them with pointers to avoid invalidating the pointers.

What is a wild pointer?

A wild pointer is a pointer that has not been initialized or points to an undefined memory location. Using a wild pointer can lead to segmentation faults and other runtime errors.

How do I avoid using wild pointers?

To avoid using wild pointers, always initialize your pointers with appropriate values before using them. Additionally, be careful when passing pointers as function arguments or returning them from functions to ensure they are properly initialized.

What is the difference between a stack and a heap in C?

In C, the stack is a region of memory used for function call frames and local variables, while the heap is a region of memory that can be dynamically allocated and deallocated using pointers and functions like malloc and free. The stack is managed automatically by the operating system or compiler, while the heap must be managed manually by the programmer.