Arrays in C: Declaring, Initializing, and Looping Through Them

An array is a fixed-size block of elements of the same type, laid out one after another in memory. That contiguous layout is the whole story: it is why indexing is instant, why arrays and pointers are so closely related, and why C can hand you the address of element zero and let you find the rest by arithmetic.

Declaring an Array

Element type, name, and a size in brackets:

int    scores[5];       // 5 ints
double prices[100];     // 100 doubles
char   initials[3];     // 3 chars

The size is the number of elements, and it must be known where the array is declared - usually a literal or a #defined constant. The memory is reserved immediately; nothing is allocated later.

A freshly declared local array contains garbage, not zeros:

#include <stdio.h>

int main(void) {
    int uninitialized[5];        // contents are indeterminate
    int zeroed[5] = {0};         // every element is 0

    printf("zeroed:        ");
    for (int i = 0; i < 5; i++) printf("%d ", zeroed[i]);

    printf("\nuninitialized: ");
    for (int i = 0; i < 5; i++) printf("%d ", uninitialized[i]);
    printf("   <-- whatever was in that memory\n");

    return 0;
}

The second row may print zeros, may print huge numbers, and may differ between runs or between a debug and a release build. Reading those values is undefined behavior; initialize before you read.

Initializing

Several forms, all useful:

#include <stdio.h>

int main(void) {
    int a[5] = {10, 20, 30, 40, 50};   // full list
    int b[5] = {1, 2};                 // rest are zero-filled: 1 2 0 0 0
    int c[5] = {0};                    // the whole array is zero
    int d[]  = {7, 8, 9};              // size deduced: 3 elements
    int e[5] = {[4] = 99, [0] = 1};    // designated initializers (C99)

    int n = sizeof d / sizeof d[0];

    printf("a: "); for (int i = 0; i < 5; i++) printf("%d ", a[i]);
    printf("\nb: "); for (int i = 0; i < 5; i++) printf("%d ", b[i]);
    printf("\nc: "); for (int i = 0; i < 5; i++) printf("%d ", c[i]);
    printf("\nd: "); for (int i = 0; i < n; i++) printf("%d ", d[i]);
    printf("  (size deduced as %d)", n);
    printf("\ne: "); for (int i = 0; i < 5; i++) printf("%d ", e[i]);
    printf("\n");

    return 0;
}

The {0} idiom is the one to remember: any elements you do not list are zero-initialized, so a single zero zeroes the whole array. Designated initializers ([4] = 99) let you set specific positions and leave the rest at zero, which is handy for lookup tables that are mostly empty.

One thing you cannot do is assign an array after the fact:

int a[3] = {1, 2, 3};
int b[3];
b = a;                    // error: an array is not assignable
memcpy(b, a, sizeof a);   // this is how you copy one

Indexing Starts at Zero

The first element is arr[0] and the last is arr[n-1]. There is no arr[n].

#include <stdio.h>

int main(void) {
    int scores[5] = {88, 92, 75, 60, 100};

    printf("first  scores[0] = %d\n", scores[0]);
    printf("third  scores[2] = %d\n", scores[2]);
    printf("last   scores[4] = %d\n", scores[4]);

    scores[1] = 95;                       // write to an element
    printf("after update, scores[1] = %d\n", scores[1]);

    printf("\naddresses (note the even spacing):\n");
    for (int i = 0; i < 5; i++) {
        printf("  scores[%d] at %p\n", i, (void *)&scores[i]);
    }

    return 0;
}

Run that last loop and look at the addresses: each is exactly sizeof(int) bytes past the one before. The elements really are laid out end to end:

 index      0         1         2         3         4
         +--------+--------+--------+--------+--------+
 value   |   88   |   95   |   75   |   60   |  100   |
         +--------+--------+--------+--------+--------+
 offset   +0       +4       +8       +12      +16      bytes
          ^
          &scores[0], which is also what `scores` decays to

Zero-based indexing is not an arbitrary choice - it makes the index an offset from the start, which is exactly what the address arithmetic needs. scores[i] is defined as *(scores + i); see pointers and arrays.

Finding the Length

C does not store an array's length anywhere at runtime, but the compiler knows it, and sizeof gives you access:

#include <stdio.h>

int main(void) {
    double prices[] = {4.99, 12.50, 0.99, 7.25};

    printf("total bytes    = %zu\n", sizeof prices);
    printf("bytes per item = %zu\n", sizeof prices[0]);
    printf("length         = %zu\n", sizeof prices / sizeof prices[0]);

    return 0;
}

sizeof(arr) / sizeof(arr[0]) is the idiom. Dividing by arr[0] rather than by a hard-coded sizeof(double) means the line keeps working if you change the element type.

The trap: this only works where the array was declared. Pass the array to a function and the parameter is a pointer, so sizeof measures the pointer instead - typically 8 bytes, giving a "length" of 1 or 2. That is why every array-taking function in C also takes a count:

#include <stdio.h>

int sum(const int *arr, int n) {       // the length must be passed in
    int total = 0;
    for (int i = 0; i < n; i++) {
        total += arr[i];
    }
    return total;
}

int main(void) {
    int data[6] = {3, 1, 4, 1, 5, 9};
    int n = sizeof data / sizeof data[0];   // computed HERE, where it is correct

    printf("length = %d\n", n);
    printf("sum    = %d\n", sum(data, n));

    return 0;
}

Looping Over an Array

The standard shape is a for loop from 0 while i < n:

#include <stdio.h>

int main(void) {
    int temps[7] = {18, 21, 25, 22, 19, 17, 24};
    int n = sizeof temps / sizeof temps[0];

    int total = 0, hottest = temps[0], coldest = temps[0];

    for (int i = 0; i < n; i++) {
        total += temps[i];
        if (temps[i] > hottest) hottest = temps[i];
        if (temps[i] < coldest) coldest = temps[i];
    }

    printf("readings: ");
    for (int i = 0; i < n; i++) printf("%d ", temps[i]);

    printf("\naverage:  %.1f\n", (double)total / n);
    printf("hottest:  %d\n", hottest);
    printf("coldest:  %d\n", coldest);

    return 0;
}

Note i < n, not i <= n. With n elements the valid indices are 0 through n - 1, so <= runs one extra pass and reads past the end. Seeding hottest and coldest from temps[0] rather than from 0 is the other habit worth copying - starting a maximum at zero quietly breaks on all-negative data.

Out of Bounds Is Undefined Behavior

This is the part of C that surprises people coming from other languages. There is no bounds checking. None at compile time, none at runtime. arr[10] on a five-element array is not an error - it is an address computation the compiler performs without comment.

int arr[5] = {1, 2, 3, 4, 5};
arr[7] = 99;     // writes 8 bytes past the end of the array
int x = arr[-1]; // reads before the start

What happens next is undefined behavior, and its symptoms are unhelpfully varied:

• it appears to work, because the memory it hit was unused;
• another variable changes for no visible reason;
• the program crashes with a segmentation fault, possibly much later;
• the behavior differs between -O0 and -O2.

"Appears to work" is the dangerous one, because it means the bug ships. Three defenses:

1. Loop with i < n. Most overruns are off-by-one errors in a loop condition.
2. Validate indices that come from input.

#include <stdio.h>

int main(void) {
    int arr[5] = {10, 20, 30, 40, 50};
    int n = 5;

    int requests[4] = {2, 5, -1, 4};    // two of these are out of range

    for (int i = 0; i < 4; i++) {
        int idx = requests[i];
        if (idx >= 0 && idx < n) {
            printf("arr[%d] = %d\n", idx, arr[idx]);
        } else {
            printf("index %d rejected (valid range is 0..%d)\n", idx, n - 1);
        }
    }

    return 0;
}

3. Build with a sanitizer while developing. gcc -fsanitize=address -g prog.c turns most overruns into an immediate report naming the file, line, and the array involved.

Arrays of Other Types

The same syntax works for any element type, including structs:

#include <stdio.h>

typedef struct {
    const char *name;
    int         score;
} Player;

int main(void) {
    Player players[3] = {
        {"Ada",   91},
        {"Grace", 78},
        {"Ken",   85}
    };
    int n = sizeof players / sizeof players[0];

    for (int i = 0; i < n; i++) {
        printf("%-6s %3d\n", players[i].name, players[i].score);
    }

    // an array of char is a string when it ends with '\0'
    char word[6] = "hello";        // 5 characters plus the terminator
    printf("\nword = %s (%zu bytes of storage)\n", word, sizeof word);

    return 0;
}

The char word[6] = "hello"; line is worth a pause: a C string is just a char array whose last meaningful byte is '\0'. That terminator is why the array needs six slots for five letters.

Variable-Length Arrays, Briefly

C99 allows an array whose size is a runtime value:

int n = get_count();
int buffer[n];        // a variable-length array

Two cautions. The size is fixed once the array is created, so a VLA is not a growable list. And the memory comes from the stack, so a large or attacker-controlled n can overflow it and crash the program - which is why many projects, including the Linux kernel, ban VLAs outright. They are also optional for C11 implementations to support.

When the size is genuinely unknown until runtime, allocate instead:

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    int n = 6;                              // pretend this came from input

    int *arr = malloc(n * sizeof *arr);     // heap, not stack
    if (arr == NULL) {
        return 1;
    }

    for (int i = 0; i < n; i++) {
        arr[i] = (i + 1) * (i + 1);
    }
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);              // indexing works exactly the same
    }
    printf("\n");

    free(arr);
    return 0;
}

Note that arr[i] reads identically whether arr is an array or a pointer to allocated memory - the indexing syntax does not care. Full details in dynamic memory.