Array size and bounds in C - Deep Dive

Overview - Array size and bounds

What is it?

An array in C is a collection of elements stored in contiguous memory locations. The size of an array is the total number of elements it can hold, which must be fixed at compile time for static arrays. Bounds refer to the valid range of indices you can use to access elements, starting from zero up to one less than the size. Accessing outside these bounds leads to undefined behavior.

Why it matters

Knowing the size and bounds of arrays is crucial because it prevents errors like accessing invalid memory, which can crash programs or cause security issues. Without understanding this, programs might read or write data they shouldn't, leading to unpredictable results. Proper handling of array size and bounds ensures safe and reliable code.

Where it fits

Before learning about array size and bounds, you should understand basic variables and memory concepts in C. After this, you can learn about pointers, dynamic memory allocation, and data structures like linked lists that build on these ideas.

Mental Model

Core Idea

An array is like a row of mailboxes numbered from zero to size minus one, and you must only open mailboxes within that range to avoid trouble.

Think of it like...

Imagine a row of numbered mailboxes outside a house. Each mailbox holds one letter. The total number of mailboxes is fixed. You can only open mailboxes with numbers from zero up to the last mailbox number. Trying to open a mailbox outside this range is like reaching into thin air or someone else's property.

Array of size 5:
┌─────┬─────┬─────┬─────┬─────┐
│[0]  │[1]  │[2]  │[3]  │[4]  │
├─────┼─────┼─────┼─────┼─────┤
│ val │ val │ val │ val │ val │
└─────┴─────┴─────┴─────┴─────┘
Valid indices: 0 to 4
Invalid indices: <0 or >=5

Build-Up - 7 Steps

1

Foundation

What is an array in C

Concept: Introduce the basic idea of arrays as fixed-size collections of elements.

In C, an array is a group of elements of the same type stored next to each other in memory. You declare an array by specifying its type and size, for example: int numbers[5]; This creates space for 5 integers.

Result

You have a block of memory reserved for 5 integers, accessible by indices 0 to 4.

Understanding that arrays are fixed-size blocks of memory helps you see why their size matters and why you must respect their bounds.

2

Foundation

Array indexing and valid bounds

Concept: Explain how to access elements using indices and what the valid range is.

Array elements are accessed using indices starting at 0. For an array of size N, valid indices are 0, 1, ..., N-1. For example, numbers[0] accesses the first element, numbers[4] the last in a size 5 array.

Result

You can read or write elements safely only within these indices.

Knowing the zero-based indexing and valid bounds prevents common errors like off-by-one mistakes.

3

Intermediate

What happens when bounds are exceeded

🤔Before reading on: do you think accessing numbers[5] in a size 5 array causes a compile error or runs but is unsafe? Commit to your answer.

Concept: Introduce the concept of undefined behavior when accessing out-of-bounds indices.

C does not check if you access an index outside the array bounds. For example, numbers[5] in a size 5 array accesses memory beyond the array. This can cause unpredictable results, crashes, or security vulnerabilities.

Result

The program may crash, produce wrong data, or behave inconsistently.

Understanding that C trusts you to stay within bounds explains why bugs from out-of-bounds access are common and dangerous.

4

Intermediate

Calculating array size with sizeof operator

🤔Before reading on: do you think sizeof(numbers) gives the number of elements or total bytes? Commit to your answer.

Concept: Teach how to find the number of elements in an array using sizeof.

sizeof(numbers) returns the total bytes used by the array. Dividing by sizeof(element_type) gives the number of elements. For example: int numbers[5]; size_t size = sizeof(numbers) / sizeof(numbers[0]); This sets size to 5.

Result

You can programmatically find array size at compile time for static arrays.

Knowing how to calculate array size helps write safer loops and avoid hardcoding sizes.

5

Intermediate

Arrays decay to pointers in function calls

🤔Before reading on: do you think passing an array to a function passes the whole array or just a pointer? Commit to your answer.

Concept: Explain that arrays become pointers when passed to functions, losing size information.

When you pass an array to a function, it decays to a pointer to its first element. The function receives only the pointer, not the size. For example: void printArray(int arr[]) { /* no size info */ } This means you must pass the size separately or use sentinel values.

Result

Functions cannot know array size automatically, risking out-of-bounds access if size is wrong.

Understanding array decay clarifies why size parameters are common and why bounds checking is manual.

6

Advanced

Static vs dynamic arrays and bounds

🤔Before reading on: do you think dynamic arrays have fixed size like static arrays? Commit to your answer.

Concept: Introduce dynamic arrays allocated at runtime and how their size and bounds differ.

Static arrays have fixed size known at compile time. Dynamic arrays use pointers and memory allocation functions like malloc to create arrays whose size can be decided at runtime. You must track their size manually and still respect bounds.

Result

Dynamic arrays offer flexibility but require careful size management to avoid errors.

Knowing the difference helps choose the right array type and manage memory safely.

7

Expert

Why C lacks built-in bounds checking

🤔Before reading on: do you think C omits bounds checking for performance or simplicity? Commit to your answer.

Concept: Explore the design reasons behind C's lack of automatic bounds checking.

C was designed for efficiency and close hardware control. Automatic bounds checking would slow down programs and add complexity. Instead, C trusts programmers to manage memory carefully. This design choice trades safety for speed and flexibility.

Result

Programmers must write careful code or use tools to detect out-of-bounds errors.

Understanding this tradeoff explains why C is powerful but requires discipline and why modern languages add safety features.

Under the Hood

Arrays in C are blocks of memory where each element is stored sequentially. The compiler calculates the address of an element by adding the index multiplied by the element size to the base address. There is no runtime check to verify if the index is within bounds, so accessing outside the allocated memory reads or writes unknown locations.

Why designed this way?

C was created in the early 1970s to write operating systems and system software efficiently. The designers prioritized speed and low-level memory control over safety. Bounds checking was considered too costly in performance and was left to the programmer to handle.

Base address (array start)
┌───────────────┐
│ Element 0     │
├───────────────┤
│ Element 1     │
├───────────────┤
│ Element 2     │
├───────────────┤
│ Element 3     │
├───────────────┤
│ Element 4     │
└───────────────┘
Address of element i = base + i * sizeof(element)
No bounds check at runtime

Myth Busters - 4 Common Misconceptions

Quick: Does C automatically prevent you from accessing array elements out of bounds? Commit to yes or no.

Common Belief: C automatically checks array bounds and prevents invalid access.

Reality: C does not perform any bounds checking at runtime; accessing out-of-bounds memory is undefined behavior.

Why it matters: Believing in automatic checks leads to bugs that are hard to find and can cause crashes or security holes.

Quick: Does sizeof(array) always give the number of elements? Commit to yes or no.

Common Belief: sizeof(array) returns the number of elements in the array.

Reality: sizeof(array) returns the total size in bytes, not the element count. You must divide by sizeof(element) to get the number of elements.

Why it matters: Misusing sizeof can cause loops to run too many or too few times, leading to errors.

Quick: When passing an array to a function, does the function know the array size automatically? Commit to yes or no.

Common Belief: Functions receive the full array including its size when passed as a parameter.

Reality: Arrays decay to pointers when passed to functions, so size information is lost unless passed separately.

Why it matters: Assuming size is known can cause out-of-bounds access and bugs.

Quick: Can you safely access negative indices of an array in C? Commit to yes or no.

Common Belief: Negative indices can be used to access elements before the start of the array.

Reality: Negative indices access memory before the array, which is invalid and causes undefined behavior.

Why it matters: Using negative indices can corrupt memory and crash programs.

Expert Zone

1

Pointer arithmetic and array indexing are interchangeable in C, but pointer arithmetic can lead to subtle bugs if not carefully managed.

2

Some compilers offer optional bounds checking as an extension or during debugging, but this is not standard C behavior.

3

Multidimensional arrays have contiguous memory layout, but accessing them incorrectly can cause subtle out-of-bounds errors due to row-major order.

When NOT to use

Static arrays are not suitable when the size is unknown at compile time or needs to change dynamically. In such cases, use dynamic memory allocation with pointers or higher-level data structures like linked lists or vectors.

Production Patterns

In production C code, array sizes are often passed explicitly to functions to ensure safe access. Developers use tools like Valgrind or compiler sanitizers to detect out-of-bounds errors. For performance-critical code, manual bounds checks may be added only in debug builds.

Connections

Pointer arithmetic

Arrays and pointers are closely related; array indexing is a form of pointer arithmetic.

Understanding arrays as pointers helps grasp how memory is accessed and why bounds checking is manual.

Memory safety in programming languages

Array bounds checking is a key aspect of memory safety enforced in some languages but manual in C.

Knowing how C handles arrays clarifies why languages like Rust or Java add automatic bounds checks for safety.

Physical mailboxes

Both arrays and mailboxes have fixed slots accessed by numbers within a valid range.

This analogy helps understand why accessing outside the range is invalid and risky.

Common Pitfalls

#1 Accessing array elements beyond their declared size.

Wrong approach:

int arr[3] = {1, 2, 3};
int x = arr[3]; // Out-of-bounds access

Correct approach:

int arr[3] = {1, 2, 3};
int x = arr[2]; // Access last valid element

Root cause:

Misunderstanding that valid indices go from 0 to size-1, leading to off-by-one errors.

#2 Using sizeof on a pointer instead of an array to get size.

Wrong approach:

void func(int *arr) {
size_t size = sizeof(arr) / sizeof(arr[0]); // Incorrect
}

Correct approach:

void func(int *arr, size_t size) {
// Use size parameter passed explicitly
}

Root cause:

Confusing arrays and pointers causes incorrect size calculations inside functions.

#3 Assuming negative indices are valid for arrays.

Wrong approach:

int arr[5];
int val = arr[-1]; // Invalid access

Correct approach:

int arr[5];
int val = arr[0]; // Use valid indices only

Root cause:

Not understanding that array indices must be non-negative and within bounds.

Key Takeaways

Arrays in C are fixed-size blocks of memory accessed by zero-based indices.

Valid array indices range from 0 to size minus one; accessing outside this range causes undefined behavior.

C does not check array bounds automatically, so programmers must manage sizes and indices carefully.

When passing arrays to functions, they decay to pointers and lose size information, requiring explicit size parameters.

Understanding array size and bounds is essential for writing safe, efficient, and reliable C programs.