Pointers and arrays in C

Introduction

Pointers and arrays let you work directly with memory locations. This helps you handle data efficiently and understand how computers store information.

When you want to access or change elements in a list quickly.

When you need to pass large arrays to functions without copying all data.

When working with strings, which are arrays of characters.

When you want to create dynamic data structures like linked lists.

When you want to understand how memory works in your program.

Syntax

C

/* Define an array and a pointer to its first element */
int numbers[5] = {10, 20, 30, 40, 50};
int *pointer_to_numbers = numbers;

/* Access elements using pointer arithmetic */
int first = *pointer_to_numbers;       // 10
int second = *(pointer_to_numbers + 1); // 20

An array name like numbers acts like a pointer to its first element.

You can move the pointer to access other elements by adding an index.

Examples

Basic example showing how to access array elements using a pointer.

C

int values[3] = {5, 10, 15};
int *ptr = values;

// Access first element
int first_value = *ptr; // 5

// Access second element
int second_value = *(ptr + 1); // 10

Edge case: empty array has no elements, so pointer arithmetic should be avoided.

C

int *ptr = NULL;

// Accessing elements here is unsafe because array is empty.

Edge case: array with one element, pointer can access only that element safely.

C

int single_element[1] = {42};
int *ptr = single_element;

int value = *ptr; // 42

// Moving pointer beyond this is unsafe.

Pointer pointing to the last element of the array.

C

int data[4] = {1, 2, 3, 4};
int *ptr = data + 3; // points to last element

int last_value = *ptr; // 4

Sample Program

This program shows how to access and modify array elements using pointers. It prints the array elements first using normal array indexing, then using pointer arithmetic. Finally, it changes the third element through the pointer and prints the updated array.

C

#include <stdio.h>

int main() {
    int numbers[5] = {10, 20, 30, 40, 50};
    int *pointer_to_numbers = numbers; // points to first element

    printf("Array elements using array syntax:\n");
    for (int i = 0; i < 5; i++) {
        printf("numbers[%d] = %d\n", i, numbers[i]);
    }

    printf("\nArray elements using pointer arithmetic:\n");
    for (int i = 0; i < 5; i++) {
        printf("*(pointer_to_numbers + %d) = %d\n", i, *(pointer_to_numbers + i));
    }

    // Change third element using pointer
    *(pointer_to_numbers + 2) = 100;

    printf("\nAfter changing third element via pointer:\n");
    for (int i = 0; i < 5; i++) {
        printf("numbers[%d] = %d\n", i, numbers[i]);
    }

    return 0;
}

Important Notes

Time complexity to access any element by pointer or array index is O(1).

Space complexity is the same for arrays and pointers; pointers just hold an address.

Common mistake: moving pointer beyond array bounds causes undefined behavior.

Use pointers when you want efficient access or to pass arrays to functions without copying.

Summary

Pointers can point to the first element of an array.

You can access array elements by moving the pointer with arithmetic.

Be careful not to go outside the array limits with pointers.

Practice

1. What does a pointer to an array in C typically store?

easy

A. The address of the first element of the array

B. The total number of elements in the array

C. The sum of all elements in the array

D. The value of the last element in the array

Solution

1. Step 1: Understand pointer basics

   A pointer stores a memory address, not values or counts.

2. Step 2: Pointer to array points to first element

   In C, a pointer to an array points to the first element's address.

3. Final Answer:

   The address of the first element of the array -> Option A

4. Quick Check:

   Pointer = first element address [OK]

Hint: Pointers hold addresses, not values or counts [OK]

Common Mistakes:

• Thinking pointer stores array size
• Confusing pointer with array value
• Assuming pointer stores last element

2. Which of the following is the correct way to declare a pointer to an integer array in C?

easy

A. int ptr[];

B. int *ptr;

C. int &ptr;

D. int ptr*;

Solution

1. Step 1: Recall pointer declaration syntax

   In C, a pointer to int is declared as int *ptr;

2. Step 2: Check other options for syntax errors

   int ptr[] declares an array, not a pointer; int &ptr is invalid in C; int ptr* is incorrect syntax.

3. Final Answer:

   int *ptr; -> Option B

4. Quick Check:

   Pointer syntax uses * before variable [OK]

Hint: Pointer declaration uses * before variable name [OK]

Common Mistakes:

• Using array syntax instead of pointer
• Confusing C++ reference (&) with pointer
• Placing * after variable name incorrectly

3. What is the output of the following C code?

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

medium

A. 10

B. 30

C. Garbage value

D. 20

Solution

1. Step 1: Understand pointer arithmetic

   p points to arr[0], so p + 1 points to arr[1].

2. Step 2: Dereference pointer at p + 1

   *(p + 1) gives value at arr[1], which is 20.

3. Final Answer:

   20 -> Option D

4. Quick Check:

   *(p+1) = arr[1] = 20 [OK]

Hint: Pointer + 1 moves to next array element [OK]

Common Mistakes:

• Confusing *(p+1) with *p
• Assuming pointer arithmetic adds 1 byte
• Expecting arr[0] value instead

4. Identify the error in this C code snippet:

int arr[3] = {1, 2, 3};
int *p = arr + 3;
printf("%d", *p);

medium

A. Missing semicolon after array declaration

B. Array size is incorrect

C. Pointer points outside array bounds causing undefined behavior

D. Pointer declaration syntax is wrong

Solution

1. Step 1: Analyze pointer assignment

   arr + 3 points one element past the last array element (out of bounds).

2. Step 2: Dereferencing out-of-bounds pointer

   *p accesses invalid memory, causing undefined behavior.

3. Final Answer:

   Pointer points outside array bounds causing undefined behavior -> Option C

4. Quick Check:

   Pointer out of array range = error [OK]

Hint: Pointer must stay within array limits [OK]

Common Mistakes:

• Ignoring pointer out-of-bounds access
• Thinking array size is wrong
• Confusing pointer syntax errors

5. Given the code below, what will be printed?

int arr[] = {5, 10, 15, 20};
int *p = arr;
for(int i = 0; i < 4; i++) {
    printf("%d ", *(p + i));
}

hard

A. 5 10 15 20

B. 20 15 10 5

C. 5 5 5 5

D. Compilation error

Solution

1. Step 1: Understand the loop and pointer arithmetic

   Loop runs i from 0 to 3, *(p + i) accesses arr[i].

2. Step 2: Print each element in order

   Values printed are arr[0]=5, arr[1]=10, arr[2]=15, arr[3]=20.

3. Final Answer:

   5 10 15 20 -> Option A

4. Quick Check:

   Pointer + i accesses arr[i] in order [OK]

Hint: Pointer + i accesses array element i [OK]

Common Mistakes:

• Assuming reverse order print
• Printing same element repeatedly
• Expecting syntax error