Arrays in C Programming: Structure, Types, and Everyday Uses

What Exactly Is an Array?

An array is a fixed-size collection of elements of the SAME type, stored contiguously in memory, accessed by index.

Four properties, each important:

1. Same type — an array holds one type of thing. All int, or all float, or all char. You can't mix.
2. Fixed size — the size is decided when you create it and never changes.
3. Contiguous memory — elements sit next to each other in memory, back to back, with no gaps.
4. Indexed from 0 — the first element is at index 0, which means the last is at size - 1.

That contiguity and 0-based indexing aren't arbitrary quirks — they're what make arrays fast and make C's pointer arithmetic work later. Remember them; they explain nearly every array behavior you'll meet.

Creating an Array: Declaration and Initialization

Declaration (no values yet):

int marks[5];
// 5 integers, values are GARBAGE

⚠️ Watch out: like the auto variables from our storage classes tutorial, an uninitialized array holds garbage. It doesn't start at zero.

Declaration with initialization:

int marks[5] = {
    45, 62, 78, 34, 90
}
;
// size and values

Let the compiler count for you:

int marks[] = {
    45, 62, 78, 34, 90
}
;
// size becomes 5 automatically

Partial initialization — the rest become 0:

int scores[5] = {
    10, 20
}
;
// → {
10, 20, 0, 0, 0
}

Zero everything at once (a very common trick):

int counts[100] = {
    0
}
;
// ALL elements set to 0

That last one is worth memorizing — = {0} is the standard C idiom for "initialize this entire array to zeros." It works because partially-initialized arrays fill the remainder with zeros.

(Suggested image: the same array declared four ways, each shown as a filled row of memory boxes — the "partial init becomes 0" case is the one people find most useful)

Accessing Elements: The Index

Reading and writing array elements uses square brackets with an index:

#include <stdio.h>
int main() {
    int marks[5] = {
        45, 62, 78, 34, 90
    };
    printf("%d\n", marks[0]);
    // 45  — first element    printf("%d\n", marks[2]);       // 78  — third element    printf("%d\n", marks[4]);       // 90  — LAST element (index 4, not 5!)
    marks[1] = 70;
    // overwrite the second element    printf("%d\n", marks[1]);       // 70
    return 0;
}

The single most important array fact: for an array of size n, valid indexes are 0 through n - 1. There is no element at index n.

int arr[5];
arr[5] = 99;
// ✗ OUT OF BOUNDS — index 5 doesn't exist!

And here's C's brutal honesty: that code compiles. C does not check array bounds at runtime. Writing past the end corrupts neighboring memory, and reading past it returns garbage — no error message, just mysterious bugs or crashes. This is the classic buffer overflow we first met in the gets() tutorial, and it's the reason "array bounds" is a recurring theme in security.

(Suggested image: a diagram showing valid indexes 0–4 in green and the out-of-bounds slot 5 in red with a warning icon, plus a memory-corruption arrow)

Looping Through Arrays: Where They Earn Their Keep

Arrays and loops are a matched pair. Since indexes are sequential, a for loop walks the array perfectly:

#include <stdio.h>
int main() {
    int marks[5] = {
        45, 62, 78, 34, 90
    };
    int total = 0;
    int n = 5;
    for (int i = 0; i < n; i++) {
        // note: i < n, not i <= n!        printf("marks[%d] = %d\n", i, marks[i]);        total += marks[i];    }
        printf("Total   : %d\n", total);
        printf("Average : %.2f\n",(float)total / n);
        return 0;
    }

Output:

marks[0] = 45marks[1] = 62marks[2] = 78marks[3] = 34marks[4] = 90Total : 309Average : 61.80

Notice the loop condition: i < n, not i <= n. The fencepost error we discussed in the loops cluster is most dangerous with arrays — i <= n tries to access index n, which doesn't exist. When array loops misbehave, check this operator first.

Computing the size safely (instead of hard-coding 5):

int n = sizeof(marks) / sizeof(marks[0]);

sizeof(marks) gives the whole array's byte size; sizeof(marks[0]) gives one element's. Divide them and you get the element count — 20 bytes ÷ 4 bytes = 5. This idiom adapts automatically when the array grows, which is why you'll see it constantly in real C code.

Array Memory Layout: Why It Works

Let's look under the hood, because this explains arrays' speed and unlocks pointers later.

int nums[4] = {
    10, 20, 30, 40
}
;

In memory (assuming 4-byte integers), that looks like:

Address: 1000 1004 1008 1012Value: 10 20 30 40Index: 0 1 2 3

Three consequences:

1. Index → address is pure arithmetic. Element i lives at base + (i × element_size). So nums[2] = address 1000 + (2 × 4) = 1008. That's why array access is O(1) — constant time, no searching, regardless of size. Accessing element 0 and element 999,999 cost the same.

2. The array name is a pointer to the first element.nums is essentially &nums[0]. You already glimpsed this in the prototypes tutorial (where array parameters "decay" to pointers) and it's the entire bridge between arrays and pointers.

3. Contiguity enables fast iteration. Because elements are packed with no gaps, walking the array sequentially is extremely cache-friendly — a big reason array-based code runs fast.

(Suggested image: the address-diagram above, with an arrow showing how index 2 maps to address 1008 via base + i × size — this is the graphic that makes array-pointer connections click later)

The Types of Arrays

One-Dimensional Arrays (1D)

A single row of elements — the kind we've been using:

int marks[5];
float prices[10];
char letters[26];

Think: a list. 1D arrays get their own deep-dive tutorial next in this cluster.

Two-Dimensional Arrays (2D)

A grid — rows and columns:

int grid[3][4];
// 3 rows, 4 columns
int matrix[2][3] = {
{
        1, 2, 3
    }
    , {
        4, 5, 6
    }
}
;

Access with two indexes: matrix[0][2] is row 0, column 2 → value 3.

Think: a table, a chessboard, a spreadsheet, an image's pixels. 2D arrays get their own tutorial later in this cluster.

Multidimensional Arrays (3D+)

Rare, but legal — mostly for volumetric data:

int cube[3][3][3];
// a 3×3×3 block of values

Think: a Rubik's cube of numbers, or RGB image channels, or physics simulations. You'll rarely need one, but know they exist.

(Suggested image: the three types shown as shapes — 1D as a line of boxes, 2D as a grid, 3D as a cube of grids)

Types of Arrays by Data Type

Categorizing by element type is quick:

That character-array row is worth pausing on: every string you've written in this series has been a char array.char name[] = "Ravi"; is really an array of {'R','a','v','i','\0'} — with that hidden null terminator marking the end. Strings are arrays; arrays are strings. (Full treatment in the Strings cluster, coming later.)

Everyday Uses of Arrays

Arrays aren't academic — they're in nearly every real program:

1. Storing many values of the same kind

int examScores[40];
// a class's scoresfloat monthlyExpenses[12];
// a year of spending

2. Statistics — with a single pass

int arr[6] = {
    23, 78, 45, 90, 12, 67
}
;
int max = arr[0], min = arr[0], sum = 0;
for (int i = 0;
i < 6;
i++) {
    if (arr[i] > max) max = arr[i];
    if (arr[i] < min) min = arr[i];
    sum += arr[i];
}
// max = 90, min = 12, sum = 315

3. Lookup tables — replace slow computations with array reads:

int squareTable[10];
for (int i = 0;
i < 10;
i++) squareTable[i] = i * i;
// now squareTable[7] is instantly 49

4. Strings and text handling — everything from names to paragraphs:

char username[30];
char message[256];

5. Grids and matrices — 2D arrays for boards, tables, and images.

6. Sorting and searching — the classic algorithms (bubble sort, linear search, binary search) all operate on arrays, and each has its own tutorial coming in this cluster.

(Suggested image: a "where are arrays used" collage graphic — score lists, a chessboard grid, a lookup table, a text string)

The Classic Array Mistakes

1. The fencepost error — for (i = 0; i <= n; i++) accesses index n, which doesn't exist. Use i < n.
2. Assuming an uninitialized array is zeroed — it's garbage. Use = {0} if you need zeros.
3. Exceeding bounds without any error — C won't stop you. Writing arr[10] on a 10-element array silently corrupts memory. Compile with -Wall -Wextra and, crucially, test boundaries.
4. Confusing the size and the last index — int arr[5] has 5 elements, last index 4. The declaration number is the count.
5. Trying to copy one array with = — this is the big one, and it deserves its own demonstration:

int a[3] = {
    1, 2, 3
};
int b[3];
b = a;
// ✗ COMPILE ERROR — you can't assign arrays!
// You must copy element by element (or use a loop / memcpy):
for (int i = 0; i < 3; i++) {
    b[i] = a[i];
    // ✓
}

Arrays aren't "values" you can assign wholesale in C, unlike the arrays in some higher-level languages. This surprises people who've used Python or JavaScript — remember it.

6. Comparing arrays with == — a == b compares addresses, not contents. Use a loop, or memcmp(), or strcmp() for strings.

(Suggested image: "6 Array Mistakes" checklist graphic — consistent with the series)

A Complete Example: A Student Marks Manager

Everything from this page working together:

#include <stdio.h>
#define MAX_STUDENTS 50
int main(void) {
    int marks[MAX_STUDENTS];
    int n;
    printf("How many students? ");
    scanf("%d", &n);
    if (n < 1 || n > MAX_STUDENTS) {
        puts("Invalid count — must be 1 to 50.");
        return 1;
    }
    // --- Read the marks ---
    for (int i = 0; i < n; i++) {
        printf("Marks for student %d: ", i + 1);
        scanf("%d", &marks[i]);
    }
    // --- Analyze in a single pass ---
    int total = 0, highest = marks[0], lowest = marks[0];
    int passed = 0, failed = 0;
    for (int i = 0; i < n; i++) {
        total += marks[i];
        if (marks[i] > highest) highest = marks[i];
        if (marks[i] < lowest) lowest = marks[i];
        if (marks[i] >= 40) passed++;
        else failed++;
    }
    // --- Report ---
    puts("\n===== CLASS REPORT =====");
    for (int i = 0; i < n; i++) {
        printf("Student %2d : %3d  %s\n",
        i + 1, marks[i], marks[i] >= 40 ? "PASS" : "FAIL");
    }
    puts("------------------------");
    printf("Highest : %d\n", highest);
    printf("Lowest  : %d\n", lowest);
    printf("Average : %.2f\n",(float)total / n);
    printf("Passed  : %d\n", passed);
    printf("Failed  : %d\n", failed);
    return 0;
}

Sample Run:

How many students? 4
Marks for student 1: 78
Marks for student 2: 35
Marks for student 3: 92
Marks for student 4: 55
===== CLASS REPORT =====
Student 1 : 78 PASS
Student 2 : 35 FAIL
Student 3 : 92 PASS
Student 4 : 55 PASS
------------------------
Highest : 92
Lowest : 35
Average : 65.00
Passed : 3
Failed : 1

Look how much real functionality comes from one array plus two loops: flexible storage, single-pass statistics, bounds checking, a formatted report with the ternary operator, and the %2d/%3d width formatting from our printf tutorial. That's a genuinely useful program — and the pattern (read into array → analyze → report) is the backbone of thousands of real applications.

Final Thoughts

Arrays are the moment C programming broadens from "handling values" to "handling collections." One name, many values, indexed access, and O(1) lookups — they're fast, simple, and everywhere. Master the four properties (same type, fixed size, contiguous, zero-indexed), the loop pattern, and the bounds discipline, and you've got the foundation for everything that follows.

And that foundation is doing real work: strings are char arrays, function parameters pass arrays as pointers, sorting and searching are array algorithms, and 2D arrays model every grid you'll ever render. This is where the interesting half of C begins.