Arrays

Introduction

In the previous lesson, you learned about functions, which help organize code into reusable blocks. Now consider a different problem: storing many related values.

Suppose you want to store the marks of five students. Without arrays, you could create five separate variables such as marks1, marks2, marks3, marks4, and marks5.

int marks1 = 80;
int marks2 = 75;
int marks3 = 90;
int marks4 = 65;
int marks5 = 88;

This approach may work for a few values, but it becomes impractical when a program needs to store hundreds or thousands of related values.

What is an Array?

An array is a collection of elements of the same data type stored in contiguous memory locations.

Instead of creating a separate variable for every value, an array stores multiple related values under one variable name. Each individual value is called an element and is accessed using an index.

int marks[5] = {80, 75, 90, 65, 88};

Why Do We Need Arrays?

int mark1 = 80;
int mark2 = 75;
int mark3 = 90;
int mark4 = 65;
int mark5 = 88;

int marks[5] = {80, 75, 90, 65, 88};

Real-World Analogy

Imagine a classroom where each student is identified by a roll number. Instead of creating a completely separate system for every student, the roll number is used to locate a particular student.

Roll Number  →  Student Name

0            →  Rahul
1            →  Amit
2            →  Priya
3            →  Neha
4            →  Karan

An array works similarly. The array name represents the complete collection, while an index identifies a particular element.

Characteristics of Arrays

Array Declaration & Initialization

Before using an array, it must be declared. An array can also be initialized with values when it is declared.

data_type array_name[size];

int marks[5];

int marks[5] = {80, 75, 90, 65, 88};

The values inside the braces are assigned to array elements in order, beginning with index 0.

int marks[] = {80, 75, 90, 65, 88};

When an initializer list is provided, the compiler can determine the array size from the number of values.

Memory Representation

Array elements are stored in contiguous memory locations. This means each element is placed directly next to the previous element in memory.

int marks[5] = {80, 75, 90, 65, 88};

Index:     0      1      2      3      4
           │      │      │      │      │
           ▼      ▼      ▼      ▼      ▼
Value:    80     75     90     65     88

Memory:  [80] → [75] → [90] → [65] → [88]

Because the elements are contiguous, the location of an element can be calculated efficiently from the array starting address and the element index.

Array Index & Accessing Elements

Every element in an array has a unique index. To access an element, write the array name followed by the required index inside square brackets.

array_name[index]

marks[0]  →  80  (First element)
marks[1]  →  75
marks[2]  →  90
marks[3]  →  65
marks[4]  →  88  (Last element)

std::cout << marks[0];

80

Example 1: Declaring and Displaying

#include <iostream>

int main()
{
    int marks[5] = {80, 75, 90, 65, 88};

    std::cout << marks[0] << std::endl;
    std::cout << marks[1] << std::endl;
    std::cout << marks[2] << std::endl;
    std::cout << marks[3] << std::endl;
    std::cout << marks[4];

    return 0;
}

80
75
90
65
88

Example 2: Updating an Element

An individual array element can be updated by assigning a new value to its index.

#include <iostream>

int main()
{
    int marks[5] = {80, 75, 90, 65, 88};

    marks[2] = 95;

    std::cout << marks[2];

    return 0;
}

Index:  0   1   2   3   4
Value: 80  75  90  65  88

Index:  0   1   2   3   4
Value: 80  75  95  65  88

95

Example 3: Using a Loop with an Array

One of the greatest advantages of arrays is that their elements can be processed efficiently using loops.

Instead of writing a separate output statement for every element, a loop can change the index automatically.

#include <iostream>

int main()
{
    int marks[5] = {80, 75, 90, 65, 88};

    for (int i = 0; i < 5; i++)
    {
        std::cout << marks[i] << std::endl;
    }

    return 0;
}

80
75
90
65
88

Program Execution Flow

The array is created first and its values are stored. A loop then uses an index to access one element at a time until every valid element has been processed.

Advantages & Limitations

Real-World Applications

Common Beginner Mistakes

// ❌ This accesses the second element
marks[1];

// ✅ This accesses the first element
marks[0];

int marks[5];

// ❌ Invalid index
marks[5];

// Valid indexes:
// 0, 1, 2, 3, 4

// ❌ Incorrect
for (int i = 0; i <= 5; i++)
{
    std::cout << marks[i];
}

// ✅ Correct
for (int i = 0; i < 5; i++)
{
    std::cout << marks[i];
}

int numbers[5];

// Values are not automatically initialized
// for a local built-in array

int numbers[5] = {};

Best Practices

const int SIZE = 5;

int marks[SIZE] = {80, 75, 90, 65, 88};

for (int i = 0; i < SIZE; i++)
{
    std::cout << marks[i] << std::endl;
}

Frequently Asked Questions

Key Takeaways

Summary

Arrays are one of the most important foundational data structures in C++. They allow programmers to store multiple related values of the same data type under one variable name.

Each array element is stored in contiguous memory and accessed using an index. Because indexing starts at 0, an array of size n has valid indexes from 0 to n - 1.

By combining arrays with loops, programmers can process large collections of data using concise and reusable logic. Understanding declaration, initialization, indexing, updating, traversal, memory layout, and array bounds prepares you for strings, multidimensional arrays, searching, sorting, and advanced data structures.