Pointers are often considered the most challenging aspect of learning C, but they're also what makes C powerful and flexible. A pointer is a variable that stores the memory address of another variable. Think of it like a signpost that points to where data is stored, rather than holding the data itself. Understanding pointers is essential for dynamic memory allocation, efficient array manipulation, and building complex data structures.
What is a Pointer?
In C, every variable is stored somewhere in memory, and that location has an address. A pointer captures and stores that address, allowing you to indirectly access and manipulate the data at that location.
Memory Diagram: +------------+ +----------------+ | pointer |-----> | variable | | (stores | | (holds data) | | address) | | | +------------+ +----------------+
Pointer Basics
1. Declaring Pointers
int *ptr; // Pointer to an integer char *cptr; // Pointer to a character double *dptr; // Pointer to a double void *vptr; // Generic pointer (can point to any type)
The asterisk * indicates that the variable is a pointer. The type tells the compiler what kind of data the pointer points to.
2. Getting Addresses with &
#include <stdio.h>
int main() {
int x = 42;
int *ptr;
ptr = &x; // & gives the address of x
printf("Value of x: %d\n", x);
printf("Address of x: %p\n", (void*)&x);
printf("Value of ptr: %p\n", (void*)ptr);
printf("Address of ptr itself: %p\n", (void*)&ptr);
return 0;
}
Output (addresses will vary):
Value of x: 42 Address of x: 0x7ffd5e3e4a4c Value of ptr: 0x7ffd5e3e4a4c Address of ptr itself: 0x7ffd5e3e4a50
**3. Dereferencing with ***
#include <stdio.h>
int main() {
int x = 42;
int *ptr = &x;
printf("x = %d\n", x); // Direct access
printf("*ptr = %d\n", *ptr); // Indirect access via pointer
*ptr = 100; // Change x through the pointer
printf("x after *ptr = 100: %d\n", x);
return 0;
}
Output:
x = 42 *ptr = 42 x after *ptr = 100: 100
Pointer Arithmetic
One of the most powerful features of pointers is arithmetic. When you add 1 to a pointer, it moves to the next element of its type, not the next byte.
#include <stdio.h>
int main() {
int arr[] = {10, 20, 30, 40, 50};
int *ptr = arr; // Points to first element
printf("Pointer arithmetic with integers:\n");
printf("arr[0] = %d, *ptr = %d\n", arr[0], *ptr);
ptr++; // Move to next integer (4 bytes forward)
printf("After ptr++: *ptr = %d (arr[1])\n", *ptr);
ptr += 2; // Move 2 integers forward (8 bytes)
printf("After ptr += 2: *ptr = %d (arr[3])\n", *ptr);
// Demonstrating byte offsets
printf("\nAddresses and offsets:\n");
printf("arr: %p\n", (void*)arr);
printf("arr + 1: %p (offset %ld bytes)\n",
(void*)(arr + 1), (char*)(arr + 1) - (char*)arr);
return 0;
}
Output:
Pointer arithmetic with integers: arr[0] = 10, *ptr = 10 After ptr++: *ptr = 20 (arr[1]) After ptr += 2: *ptr = 40 (arr[3]) Addresses and offsets: arr: 0x7ffc12345670 arr + 1: 0x7ffc12345674 (offset 4 bytes)
Pointers and Arrays
Arrays and pointers are closely related in C. In fact, the array name acts like a constant pointer to the first element.
#include <stdio.h>
int main() {
int arr[5] = {2, 4, 6, 8, 10};
int *ptr = arr; // Equivalent to int *ptr = &arr[0];
// Accessing array elements using pointer notation
printf("Array access methods:\n");
for(int i = 0; i < 5; i++) {
printf("arr[%d] = %d, *(ptr + %d) = %d, ptr[%d] = %d\n",
i, arr[i], i, *(ptr + i), i, ptr[i]);
}
// Pointer to array vs array of pointers
int *ptrToArray[5]; // Array of 5 pointers to int
int (*arrayPtr)[5]; // Pointer to an array of 5 ints
printf("\nSizeof array: %lu bytes\n", sizeof(arr));
printf("Sizeof ptr: %lu bytes\n", sizeof(ptr));
return 0;
}
Output:
Array access methods: arr[0] = 2, *(ptr + 0) = 2, ptr[0] = 2 arr[1] = 4, *(ptr + 1) = 4, ptr[1] = 4 arr[2] = 6, *(ptr + 2) = 6, ptr[2] = 6 arr[3] = 8, *(ptr + 3) = 8, ptr[3] = 8 arr[4] = 10, *(ptr + 4) = 10, ptr[4] = 10 Sizeof array: 20 bytes Sizeof ptr: 8 bytes
Pointers and Strings
Strings in C are character arrays terminated by a null character (\0). Pointers are essential for string manipulation.
#include <stdio.h>
int main() {
// String as character array
char str1[] = "Hello";
// String as pointer to string literal
char *str2 = "World";
printf("str1: %s\n", str1);
printf("str2: %s\n", str2);
// str1 is an array - can modify elements
str1[0] = 'J';
printf("Modified str1: %s\n", str1);
// str2 is a pointer to string literal - modifying is undefined behavior!
// str2[0] = 'w'; // DON'T DO THIS - may crash
// String traversal with pointer
printf("\nTraversing string with pointer:\n");
char *p = str1;
while (*p != '\0') {
printf("Character: %c, ASCII: %d\n", *p, *p);
p++; // Move to next character
}
return 0;
}
Output:
str1: Hello str2: World Modified str1: Jello Traversing string with pointer: Character: J, ASCII: 74 Character: e, ASCII: 101 Character: l, ASCII: 108 Character: l, ASCII: 108 Character: o, ASCII: 111
Pointers to Pointers (Multiple Indirection)
You can have pointers that point to other pointers, useful for multi-dimensional arrays and dynamic data structures.
#include <stdio.h>
int main() {
int x = 42;
int *ptr = &x; // Pointer to int
int **pptr = &ptr; // Pointer to pointer to int
int ***ppptr = &pptr; // Pointer to pointer to pointer to int
printf("x = %d\n", x);
printf("*ptr = %d\n", *ptr);
printf("**pptr = %d\n", **pptr);
printf("***ppptr = %d\n", ***ppptr);
// Practical example: array of strings
char *fruits[] = {"Apple", "Banana", "Orange", "Mango"};
char **fruitPtr = fruits; // Points to first string
printf("\nFruits array:\n");
for(int i = 0; i < 4; i++) {
printf("fruitPtr[%d] = %s\n", i, fruitPtr[i]);
}
return 0;
}
Output:
x = 42 *ptr = 42 **pptr = 42 ***ppptr = 42 Fruits array: fruitPtr[0] = Apple fruitPtr[1] = Banana fruitPtr[2] = Orange fruitPtr[3] = Mango
Pointers and Functions
1. Passing Pointers to Functions (Call by Reference)
#include <stdio.h>
// Function that modifies variables through pointers
void swap(int *a, int *b) {
int temp = *a;
*a = *b;
*b = temp;
}
void increment(int *x) {
(*x)++; // Parentheses needed because ++ has higher precedence than *
}
int main() {
int x = 10, y = 20;
printf("Before swap: x = %d, y = %d\n", x, y);
swap(&x, &y);
printf("After swap: x = %d, y = %d\n", x, y);
printf("\nx = %d\n", x);
increment(&x);
printf("After increment: x = %d\n", x);
return 0;
}
Output:
Before swap: x = 10, y = 20 After swap: x = 20, y = 10 x = 20 After increment: x = 21
2. Returning Pointers from Functions
#include <stdio.h>
#include <stdlib.h>
// Return pointer to static array
int* getStaticArray() {
static int arr[3] = {1, 2, 3};
return arr; // Safe - static storage duration
}
// Return pointer to dynamically allocated memory
int* createArray(int size) {
int *arr = (int*)malloc(size * sizeof(int));
if (arr != NULL) {
for(int i = 0; i < size; i++) {
arr[i] = i * 10;
}
}
return arr;
}
int main() {
int *staticArr = getStaticArray();
printf("Static array: %d, %d, %d\n",
staticArr[0], staticArr[1], staticArr[2]);
int *dynamicArr = createArray(5);
if (dynamicArr != NULL) {
printf("Dynamic array: ");
for(int i = 0; i < 5; i++) {
printf("%d ", dynamicArr[i]);
}
printf("\n");
free(dynamicArr); // Don't forget to free!
}
return 0;
}
Output:
Static array: 1, 2, 3 Dynamic array: 0 10 20 30 40
Dynamic Memory Allocation
Pointers are essential for dynamic memory management using malloc(), calloc(), and free().
#include <stdio.h>
#include <stdlib.h>
int main() {
int n;
int *arr;
printf("Enter number of elements: ");
scanf("%d", &n);
// Allocate memory
arr = (int*)malloc(n * sizeof(int));
if (arr == NULL) {
printf("Memory allocation failed!\n");
return 1;
}
// Use the allocated memory
printf("Enter %d numbers:\n", n);
for(int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
printf("You entered: ");
for(int i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
printf("\n");
// Free the allocated memory
free(arr);
// Using calloc (initializes to zero)
int *zeroArr = (int*)calloc(5, sizeof(int));
printf("\ncalloc array (initialized to zero): ");
for(int i = 0; i < 5; i++) {
printf("%d ", zeroArr[i]);
}
printf("\n");
free(zeroArr);
// realloc - resize memory
int *temp = (int*)realloc(arr, 10 * sizeof(int));
if (temp != NULL) {
arr = temp;
printf("Memory resized successfully\n");
}
return 0;
}
Function Pointers
Pointers can even point to functions, enabling callbacks and dynamic dispatch.
#include <stdio.h>
int add(int a, int b) { return a + b; }
int subtract(int a, int b) { return a - b; }
int multiply(int a, int b) { return a * b; }
// Function that takes a function pointer as parameter
int calculate(int x, int y, int (*operation)(int, int)) {
return operation(x, y);
}
int main() {
int a = 10, b = 5;
// Array of function pointers
int (*operations[])(int, int) = {add, subtract, multiply};
char *opNames[] = {"Addition", "Subtraction", "Multiplication"};
for(int i = 0; i < 3; i++) {
int result = calculate(a, b, operations[i]);
printf("%s: %d %s %d = %d\n",
opNames[i], a,
i == 0 ? "+" : (i == 1 ? "-" : "*"),
b, result);
}
return 0;
}
Output:
Addition: 10 + 5 = 15 Subtraction: 10 - 5 = 5 Multiplication: 10 * 5 = 50
Common Pointer Pitfalls
1. Uninitialized Pointers
int *ptr; // Contains garbage address *ptr = 42; // DANGER! Writing to random memory location // Always initialize pointers int x = 42; int *ptr = &x; // Safe int *ptr2 = NULL; // Safe null pointer
2. Dereferencing NULL Pointers
int *ptr = NULL;
*ptr = 42; // Crash! Dereferencing NULL
// Always check for NULL before dereferencing
if (ptr != NULL) {
*ptr = 42;
}
3. Memory Leaks
void leak() {
int *ptr = (int*)malloc(100 * sizeof(int));
// Forget to free() - memory leak!
}
// Always free dynamically allocated memory
void noLeak() {
int *ptr = (int*)malloc(100 * sizeof(int));
// Use ptr...
free(ptr); // Don't forget!
}
4. Dangling Pointers
int *ptr;
{
int x = 42;
ptr = &x;
} // x goes out of scope
// ptr now points to invalid memory (dangling pointer)
*ptr = 100; // DANGER! Undefined behavior
// Set to NULL after free to avoid dangling
free(ptr);
ptr = NULL;
5. Pointer Arithmetic Errors
int arr[5]; int *ptr = arr; ptr += 10; // Out of bounds! *ptr = 42; // DANGER! Writing outside array bounds
Pointer Size and Type
#include <stdio.h>
int main() {
printf("Pointer sizes on this system:\n");
printf("char*: %lu bytes\n", sizeof(char*));
printf("int*: %lu bytes\n", sizeof(int*));
printf("double*: %lu bytes\n", sizeof(double*));
printf("void*: %lu bytes\n", sizeof(void*));
// All pointers have the same size, but different types matter for arithmetic
printf("\nPointer arithmetic differences:\n");
char *cptr = NULL;
int *iptr = NULL;
double *dptr = NULL;
printf("char* + 1: %p\n", (void*)(cptr + 1));
printf("int* + 1: %p\n", (void*)(iptr + 1));
printf("double* + 1: %p\n", (void*)(dptr + 1));
return 0;
}
Output (typical 64-bit system):
Pointer sizes on this system: char*: 8 bytes int*: 8 bytes double*: 8 bytes void*: 8 bytes Pointer arithmetic differences: char* + 1: 0x1 int* + 1: 0x4 double* + 1: 0x8
Const and Pointers
The const keyword can be used in different positions to create various levels of pointer protection.
#include <stdio.h>
int main() {
int x = 10;
int y = 20;
// 1. Pointer to constant data
const int *p1 = &x;
// *p1 = 100; // ERROR! Can't modify data through p1
p1 = &y; // OK! Can change what p1 points to
// 2. Constant pointer to data
int *const p2 = &x;
*p2 = 100; // OK! Can modify data
// p2 = &y; // ERROR! Can't change pointer itself
// 3. Constant pointer to constant data
const int *const p3 = &x;
// *p3 = 100; // ERROR! Can't modify data
// p3 = &y; // ERROR! Can't change pointer
printf("p1 points to: %d\n", *p1);
printf("p2 points to: %d\n", *p2);
return 0;
}
Practical Example: Linked List Implementation
#include <stdio.h>
#include <stdlib.h>
// Node structure
typedef struct Node {
int data;
struct Node *next;
} Node;
// Function to create a new node
Node* createNode(int data) {
Node *newNode = (Node*)malloc(sizeof(Node));
if (newNode != NULL) {
newNode->data = data;
newNode->next = NULL;
}
return newNode;
}
// Insert at beginning
void insertAtBeginning(Node **head, int data) {
Node *newNode = createNode(data);
if (newNode != NULL) {
newNode->next = *head;
*head = newNode;
}
}
// Insert at end
void insertAtEnd(Node **head, int data) {
Node *newNode = createNode(data);
if (newNode == NULL) return;
if (*head == NULL) {
*head = newNode;
return;
}
Node *current = *head;
while (current->next != NULL) {
current = current->next;
}
current->next = newNode;
}
// Display list
void displayList(Node *head) {
Node *current = head;
while (current != NULL) {
printf("%d -> ", current->data);
current = current->next;
}
printf("NULL\n");
}
// Free list
void freeList(Node **head) {
Node *current = *head;
while (current != NULL) {
Node *temp = current;
current = current->next;
free(temp);
}
*head = NULL;
}
int main() {
Node *head = NULL;
insertAtBeginning(&head, 30);
insertAtBeginning(&head, 20);
insertAtBeginning(&head, 10);
printf("After inserting at beginning: ");
displayList(head);
insertAtEnd(&head, 40);
insertAtEnd(&head, 50);
printf("After inserting at end: ");
displayList(head);
freeList(&head);
printf("List freed\n");
return 0;
}
Output:
After inserting at beginning: 10 -> 20 -> 30 -> NULL After inserting at end: 10 -> 20 -> 30 -> 40 -> 50 -> NULL List freed
Pointer Cheat Sheet
| Operation | Syntax | Description |
|---|---|---|
| Declaration | int *ptr; | Declare pointer to int |
| Get address | ptr = &x; | Store address of x in ptr |
| Dereference | *ptr = 42; | Access data at address |
| Pointer addition | ptr + 1 | Move to next element |
| Array access | ptr[i] | Same as *(ptr + i) |
| Pointer to pointer | int **pp; | Points to another pointer |
| Function pointer | int (*func)(int); | Points to function |
| NULL pointer | ptr = NULL; | Safe pointer value |
| Dynamic allocation | malloc(n * sizeof(int)) | Allocate memory |
| Deallocation | free(ptr); | Release memory |
Common Mistakes Checklist
- [ ] Using uninitialized pointers
- [ ] Forgetting to check for NULL after
malloc - [ ] Dereferencing NULL pointers
- [ ] Memory leaks (forgetting to
free) - [ ] Using dangling pointers after
free - [ ] Array bounds errors with pointer arithmetic
- [ ] Confusing
ptr++with(*ptr)++ - [ ] Mismatched pointer types
- [ ] Forgetting that string literals are read-only
- [ ] Incorrect use of
&and*
Conclusion
Pointers are what make C both powerful and challenging. They provide direct memory access, enable dynamic data structures, and make efficient array manipulation possible. While they require careful handling, mastering pointers opens up possibilities that are difficult or impossible in higher-level languages.
Key takeaways:
- Pointers store addresses, not values
- The
&operator gets addresses, the*operator dereferences pointers - Pointer arithmetic is scaled by the type size
- Always initialize pointers and check for
NULL - Dynamically allocated memory must be explicitly freed
- Function pointers enable callbacks and polymorphism
constwith pointers creates various protection levels
Understanding pointers is the gateway to advanced C programming—dynamic data structures, operating system interfaces, embedded systems programming, and high-performance computing all rely heavily on pointer mastery. With practice and attention to detail, pointers will transform from a source of bugs into a powerful tool in your programming arsenal.