👉 Topic 13 — Pointers

A pointer lets a program work with an object through its address. Instead of storing a value such as 25, a pointer stores the address of an object.

You will use pointers to update values in a calling function, visit array elements, process strings, and use dynamically allocated storage.

13.1 What Is a Pointer?

A pointer variable stores a pointer value. It can point to an object of a suitable type, point to a function when declared as a function pointer, or hold a null pointer value.

Consider:

int age = 20;

The variable age stores the value 20. The computer also associates age with a memory location. A pointer can store that memory address.

int age = 20; int *ptr = &age;

Here:

• age stores 20.
• &age produces the address of age.
• ptr stores that address.
• *ptr accesses the object stored at that address.

 Variable ┌─────────────┐ age │ 20 │ └─────────────┘ ▲ │ │ address of age │ ┌─────────────┐ ptr │ &age │ └─────────────┘ *ptr → 20 

13.2 Why Do We Need Pointers?

13.3 The Two Most Important Pointer Operators

13.4 Declaring a Pointer

The basic syntax is:

data_type *pointer_name;

Examples:

int *p; float *pricePtr; char *letterPtr; double *valuePtr;

The type tells the compiler what kind of object the pointer is intended to point to.

13.5 Understanding int *p

Beginners often read:

int *p;

as:

"p is an integer."

That is incorrect.

The correct interpretation is:

p is a pointer to an int.

 int number = 50; int *p = &number; number ┌──────────────┐ │ 50 │ └──────────────┘ ▲ │ │ │ points to │ p ┌──────────────┐ │ address │ └──────────────┘ 

13.6 Address-of Operator &

The address-of operator obtains the address of an object.

int number = 25; printf("%p\n", (void *)&number);

The printed address can change between runs and systems. Learn the relationship between the variable and pointer rather than memorizing an address shown in one run.

printf("%p\n", (void *)ptr);

13.7 Dereference Operator *

The dereference operator accesses the object referred to by a valid pointer.

int number = 25; int *ptr = &number; printf("%d\n", *ptr);

Output:

25

The expression *ptr means:

"Access the object that ptr points to."

13.8 Reading and Modifying Through a Pointer

If ptr points to a writable variable, assigning to *ptr changes that variable. The pointer still holds the same address; the value at the target changes.

#include <stdio.h>

int main(void) {
    int number = 10;
    int *ptr = &number;
    printf("Before = %d\n", number);
    *ptr = 50;
    printf("After = %d\n", number);
    return 0;
}

Output:

Before = 10 After = 50

Why did number change? Because *ptr refers to the same object as number.

13.9 Pointer Program Tracing

int number = 10; int *ptr = &number; *ptr = 50;

 points to ptr ─────────────────────► number ┌─────────┐ │ 50 │ └─────────┘ *ptr means: "Go to the object at ptr's address." 

13.10 Pointer and Pointee

The object whose address is stored in a pointer is often called the pointee.

int x = 100; int *p = &x;

Here:

• p is the pointer.
• x is the pointee.
• &x is the address stored in p.
• *p accesses x.

13.11 Pointer Initialization

Give a pointer a valid value before using it. To dereference it, it must point to an existing object that can be accessed with the pointed-to type.

int value = 40; int *p = &value;

A pointer can also intentionally contain a null pointer value:

int *p = NULL;

A null pointer means that no object or function is selected. It is useful as a starting value when the program does not have a target yet.

13.12 NULL Pointer

A null pointer is a pointer value that compares unequal to a pointer to any object or function.

int *ptr = NULL; if (ptr == NULL) { printf("Pointer is NULL\n"); }

Modern C code may use nullptr in C23, but many educational and existing C programs use NULL. The important concept is that the pointer must not be dereferenced while it is null.

13.13 Uninitialized Pointers

This is dangerous:

int *p; *p = 10;

Declaring the pointer does not create a target object or give it a target address. Dereferencing this uninitialized pointer has undefined behavior. Assign a valid address before using it.

Use:

int value = 10; int *p = &value;

or, when there is no target yet:

int *p = NULL;

13.14 Pointer Types

The pointed-to type tells C what kind of object is being accessed. It also sets the element size used for pointer arithmetic.

13.15 Why Pointer Type Matters

Suppose:

int *p;

When *p is evaluated, the compiler interprets the object using the pointed-to type int.

For an int pointer into an array, adding 1 moves by one int element. It does not add one byte unless the pointed-to type has size one byte.

13.16 Pointer Size vs Pointed-to Object Size

Do not assume that the size of a pointer is the size of the object it points to.

int x = 10; int *p = &x; printf("%zu\n", sizeof(x)); printf("%zu\n", sizeof(p));

Use sizeof to ask about each type separately. For example, an int pointer and an int may occupy different numbers of bytes on your system.

13.17 Pointers and Functions

The function receives a copy of the pointer value. That copy points to the same caller object. Writing through the copied pointer can change the caller’s object; reassigning the local pointer does not reassign the caller’s pointer.

Example:

#include <stdio.h>

void changeValue(int *p) {
    *p = 100;
}
int main(void) {
    int number = 20;
    changeValue(&number);
    printf("%d\n", number);
    return 0;
}

Output:

100

The pointer itself is passed by value, but the copied pointer points to the same number object.

13.18 Program Tracing — Function + Pointer

 main() │ │ number = 20 │ │ changeValue(&number) ▼ changeValue(int *p) │ │ p receives a copy of number's address │ │ *p = 100 ▼ number becomes 100 │ ▼ return to main() 

13.19 Swapping Two Numbers Using Pointers

A classic pointer application is swapping two objects inside a function.

#include <stdio.h>

void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}
int main(void) {
    int x = 10;
    int y = 20;
    printf("Before: %d %d\n", x, y);
    swap(&x, &y);
    printf("After: %d %d\n", x, y);
    return 0;
}

Output:

Before: 10 20 After: 20 10

13.20 Pointer Arithmetic

Starting from an array element, pointer addition or subtraction must stay within that array or reach exactly one position past its end. Forming a pointer farther outside the array is not valid.

For example:

int numbers[] = {10, 20, 30, 40}; int *p = numbers; printf("%d\n", *p); printf("%d\n", *(p + 1)); printf("%d\n", *(p + 2));

Output:

10 20 30

The expression p + 1 does not mean "add one byte." It advances to the next int element.

13.21 Pointer Arithmetic and Array Elements

 int numbers[] = {10, 20, 30, 40}; Index: 0 1 2 3 │ │ │ │ ▼ ▼ ▼ ▼ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ │ 10 │ │ 20 │ │ 30 │ │ 40 │ └─────┘ └─────┘ └─────┘ └─────┘ ▲ │ p p + 1 → points to element 1 p + 2 → points to element 2 

The exact byte distance depends on sizeof(int), but C pointer arithmetic automatically scales by the size of the pointed-to type.

13.22 Incrementing a Pointer

int numbers[] = {10, 20, 30}; int *p = numbers; printf("%d\n", *p); p++; printf("%d\n", *p);

Output:

10 20

After p++, the pointer refers to the next array element.

13.23 Pointer Subtraction

Subtract pointers within the same array to find the distance in elements. For example, &a[4] - &a[1] gives 3, not the distance in bytes.

int numbers[] = {10, 20, 30, 40, 50}; int *p1 = &numbers[1]; int *p2 = &numbers[4]; printf("%td\n", p2 - p1);

Output:

3

The result type is ptrdiff_t, for which %td is the appropriate printf conversion.

13.24 One-Past-the-End Pointer

One position past the last element is a valid boundary pointer. Use it to stop a loop, but do not read or write through it. For five elements, a + 5 is the boundary; *(a + 5) is not an element.

int numbers[] = {10, 20, 30}; int *p = numbers; int *end = numbers + 3; while (p != end) { printf("%d\n", *p); p++; }

Here end is valid as a pointer value for the iteration boundary, but *end must not be evaluated.

13.25 Pointers and Arrays

An array expression often converts to a pointer to its first element when used in most expressions.

int numbers[] = {10, 20, 30}; int *p = numbers;

Here p points to numbers[0].

Therefore:

numbers[0] *(numbers + 0) numbers[1] *(numbers + 1) numbers[2] *(numbers + 2)

refer to corresponding elements.

13.26 Array Indexing Is Related to Pointer Arithmetic

For an array or pointer expression, the notation:

a[i]

is defined in terms of pointer arithmetic as:

*(a + i)

For example:

int a[] = {5, 10, 15}; printf("%d\n", a[1]); printf("%d\n", *(a + 1));

Both print:

10

13.27 Pointers as Function Parameters for Arrays

When an array is used as a function argument, it normally converts to a pointer to its first element. In the function’s parameter list, an array-style declaration is adjusted to a pointer declaration.

#include <stdio.h>

void printArray(int a[], int n) {
    for (int i = 0; i < n; i++) {
        printf("%d ", a[i]);
    }
}
int main(void) {
    int numbers[] = {
        10, 20, 30, 40
    };
    printArray(numbers, 4);
    return 0;
}

Output:

10 20 30 40

13.28 Important Interview Point: sizeof and Array Parameters

Consider:

void showSize(int a[]) { printf("%zu\n", sizeof(a)); }

Inside this parameter declaration, a is adjusted to a pointer parameter. Therefore sizeof(a) gives the size of the pointer, not the size of the original array.

This is why a function commonly receives the array length separately:

void process(int a[], int n)

13.29 Pointers and Strings

A C string is an array of characters terminated by a null character '\0'. A pointer can point to its first character.

char name[] = "Bhavya"; char *p = name; printf("%s\n", p);

Output:

Bhavya

The pointer can also be used to traverse the characters:

while (*p != '\0') { putchar(*p); p++; }

13.30 Character Pointer vs Character Array

Be careful with:

char *p = "Hello";

The string literal should not be modified through p. Use const char *p = "Hello" to show that the literal must not be changed through p. Use char text[] = "Hello" when you need a separate writable array.

13.31 Pointer to Pointer

A pointer variable is an object too, so it has an address. A pointer-to-pointer stores that address. One dereference reaches the pointer; a second reaches its target object.

int value = 25; int *p = &value; int **pp = &p;

 pp │ │ points to ▼ ┌───────────────┐ │ p │ │ address of │ │ value │ └───────────────┘ │ │ points to ▼ ┌───────────────┐ │ value │ │ 25 │ └───────────────┘ *pp → p **pp → value → 25 

13.32 Dereferencing Multiple Levels

int value = 25; int *p = &value; int **pp = &p; printf("%d\n", **pp);

Output:

25

Explanation:

1. pp points to p.
2. *pp gives p.
3. **pp accesses the object pointed to by p.

13.33 Const and Pointers

The const qualifier can be combined with pointer declarations in several different ways.

Pointer to const data

const int *p;

The object should not be modified through p. The pointer itself may be changed to point elsewhere.

Const pointer

int *const p = &value;

The pointer itself cannot be changed to point elsewhere after initialization, but the pointed-to int can be modified through p.

Const pointer to const data

const int *const p = &value;

Neither the pointer itself nor the object can be modified through that pointer.

13.34 Pointer Compatibility

Pointer types should be used carefully. For example:

int *p; double *q;

These pointers refer to different object types. Changing the pointer type with a cast is not enough to justify reading an int object as a float object. Access an object through a type that C permits.

The special pointer type void * can hold the address of an object of any object type and is widely used in generic C interfaces.

13.35 Void Pointers

int number = 50; void *ptr = &number;

A void * is a generic object pointer. Before dereferencing it, convert it to an appropriate pointer type or assign it to one.

printf("%d\n", *(int *)ptr);

The compiler cannot directly determine the pointed-to object type from void * alone.

13.36 Pointer Comparisons

Within the same array, relational comparisons such as p < end can show which position comes earlier. Do not use them to order unrelated allocated objects. Equality tests also let you check a pointer against NULL.

int a[] = {10, 20, 30}; int *p = &a[0]; int *q = &a[2]; if (p < q) { printf("p comes before q\n"); }

Equality and inequality comparisons are also commonly used when checking for null pointers:

if (p == NULL) { printf("No object\n"); }

13.37 Pointer Safety

Many serious C bugs involve invalid pointers.

13.38 Dangling Pointers

A dangling pointer no longer gives valid access to its former target because the target’s lifetime has ended.

For example, returning the address of an ordinary local variable from a function is invalid:

int *wrong(void) { int x = 10; return &x; }

When the function returns, the lifetime of the local object x has ended. The returned pointer cannot safely be dereferenced.

13.39 Common Pointer Mistakes

13.40 Pointer vs Value

13.41 Pointer Visualization

 int marks = 85; int *p = &marks; stores 85 ┌─────────────┐ marks ───────►│ 85 │ └─────────────┘ ▲ │ │ address │ ┌─────────────┐ p ───────────►│ &marks │ └─────────────┘ p = address of marks *p = 85 &marks = same address stored in p 

13.42 Complete Program Analysis

#include <stdio.h>

void update(int *p) {
    *p = *p + 10;
}
int main(void) {
    int marks = 70;
    int *ptr = &marks;
    printf("Before = %d\n", marks);
    update(ptr);
    printf("After = %d\n", marks);
    return 0;
}

Step 1 — Create the variable

int marks = 70;

An integer object named marks is initialized with 70.

Step 2 — Store its address

int *ptr = &marks;

ptr stores the address of marks.

Step 3 — Call the function

update(ptr);

A copy of the pointer value is passed to update.

Step 4 — Dereference

*p = *p + 10;

The function reads the caller's marks object through the pointer and changes it from 70 to 80.

Step 5 — Return to main

The updated value remains in marks.

Output:

Before = 70 After = 80

13.43 Pointers and Memory Layout — Conceptual View

The following is a conceptual model rather than a promise about exact addresses or physical memory organization.

 Object Pointer ┌──────────────┐ ┌──────────────┐ │ │ │ │ │ value │◄─────────│ address │ │ │ │ │ └──────────────┘ └──────────────┘ ▲ │ │ │ └────────── *p ───────────┘ 

Read the diagram as a relationship: the pointer identifies the object, and dereferencing reaches that object. The sample address is only a label for the explanation.

13.44 Pointers and sizeof

Remember that sizeof measures its operand’s type or object size. Applying it to a pointer does not report how many elements are in an allocation reached through that pointer.

int x = 10; int *p = &x; printf("%zu\n", sizeof(x)); printf("%zu\n", sizeof(p)); printf("%zu\n", sizeof(*p));

The third expression, sizeof(*p), corresponds to the size of the pointed-to type, int, without requiring the pointed-to object's value to be read.

13.45 Pointer Expressions to Remember

13.46 Common Confusions