Arrays

Overview — storing many values together

Without arrays you would need many separate variables (m1, m2, …). Arrays give you one name and an index: marks[0], marks[1], …

• Element — one value in the array
• Index — position; first element is index 0
• Size / length — how many elements (1D) or rows×cols (2D)
• Same type — all elements share one type (int, float, …)

What is an array? — 1D then 2D

A 1D array is a contiguous sequence of elements. Address of element i is conceptually base address + i × sizeof(element).

int a[5];   /* 5 ints: a[0] a[1] a[2] a[3] a[4] */

A 2D array is like a table: first index = row, second = column. m[i][j] is the element in row i, column j.

int m[2][3];   /* 2 rows, 3 columns — 6 ints total */
/* m[0][0] m[0][1] m[0][2] */
/* m[1][0] m[1][1] m[1][2] */

Why arrays?

• Store many values under one name instead of dozens of variables
• Random access — jump to any index in constant time with a[i]
• Easy looping — for from 0 to n - 1 for fill, sum, search, print
• Natural for tables — 2D arrays model matrices, grids, and game boards
• Less clutter — algorithms stay readable when data lives in arrays

Applications of arrays

• Marks / scores list — 1D array of student marks
• Matrices — addition, multiplication (conceptually), transpose with 2D arrays
• Images (conceptually) — pixels as a 2D grid of values
• Lookup tables — precomputed values indexed by an integer key
• Strings (related) — char arrays hold text ending with '\0'

Types of arrays

Declaration syntax — 1D and 2D

1D:

type name[size];

int marks[5];
float temp[7];
char vowels[5];

2D:

type name[rows][cols];

int matrix[3][3];   /* 3×3 ints */
int grid[2][4];     /* 2 rows, 4 columns */

Initialization of arrays — 1D and 2D

Compile-time (initializer list) — 1D:

int a[5] = {10, 20, 30, 40, 50};
int b[]  = {1, 2, 3};           /* size becomes 3 */
int c[5] = {1, 2};            /* partial: rest become 0 */
int z[5] = {0};              /* all zeros */

Compile-time — 2D:

int m[2][3] = {
    {1, 2, 3},
    {4, 5, 6}
};

int p[2][3] = {1, 2};   /* partial: rest 0 */
int q[2][3] = {0};     /* all zeros */

Writing data into arrays — 1D and 2D

Assignment (1D):

a[0] = 10;
a[1] = 20;
a[2] = 30;

Loop + scanf (1D):

for (i = 0; i < n; i++)
    scanf("%d", &a[i]);

Assignment (2D):

m[0][0] = 1;
m[0][1] = 2;
m[1][0] = 3;

Nested loop + scanf (2D):

for (i = 0; i < rows; i++)
    for (j = 0; j < cols; j++)
        scanf("%d", &m[i][j]);

Reading data from arrays — 1D and 2D

Loop + printf (1D):

for (i = 0; i < n; i++)
    printf("%d ", a[i]);
printf("\n");

Nested loops + printf (2D matrix form):

for (i = 0; i < rows; i++) {
    for (j = 0; j < cols; j++)
        printf("%d ", m[i][j]);
    printf("\n");          /* new line after each row */
}

Memory layout — 1D and row-major 2D

A 1D array occupies consecutive addresses. For int a[4], elements sit next to each other in order a[0], a[1], a[2], a[3].

A 2D array in C is stored in row-major order: all of row 0, then row 1, and so on. For int m[2][3] the sequence in memory is:

Index out of bounds — undefined behavior

C does not automatically stop you from writing a[n] or m[i][j] outside the declared ranges. Doing so is undefined behavior: the program may crash, corrupt data, or seem fine until later.

• 1D: use only 0 .. size-1
• 2D: use only 0 .. rows-1 and 0 .. cols-1
• Prefer i < n over i <= n for 0-based loops

Array name decays to a pointer (high-level)

In most expressions, the array name a decays to a pointer to its first element (&a[0]). That is why you can pass a to a function that expects int *, and why a[i] relates to *(a + i).

Important exception: sizeof(a) still sees the whole array object (in the declaring scope), not a pointer — until the name has decayed in a parameter.

Length with sizeof(array) / sizeof(array[0])

int a[] = {10, 20, 30, 40};
int n = sizeof(a) / sizeof(a[0]);  /* n == 4 */

Passing arrays to functions — intro

Functions receive a pointer to the first element (decay), not a copy of the whole array. Changes inside the function affect the caller’s array. Always pass the length for 1D.

void print1d(int a[], int n) {
    int i;
    for (i = 0; i < n; i++)
        printf("%d ", a[i]);
}

/* 2D: column size must be known (or use other pointer forms) */
void print2d(int m[][3], int rows) {
    int i, j;
    for (i = 0; i < rows; i++) {
        for (j = 0; j < 3; j++)
            printf("%d ", m[i][j]);
        printf("\n");
    }
}

2D as array of arrays — nested traversal

You can think of int m[rows][cols] as rows arrays of length cols. m[i] is row i; m[i][j] is one cell.

/* Row-major walk — visit every cell once */
for (row = 0; row < rows; row++)
    for (col = 0; col < cols; col++)
        /* use m[row][col] */ ;

• By rows: outer = row, inner = col (most common)
• By columns: outer = col, inner = row (still valid; different visit order)
• Always print \n after finishing one row when showing a matrix

Common mistakes