Static Arrays

Static Arrays: Fixed in Place

In programming, you often need to handle groups of related data. Instead of declaring a dozen separate variables, C++ lets you use an array. An array is a collection of items of the same data type, stored in a single, named block. We'll be looking at static arrays, which have a size that is fixed when the program is compiled.

Declaration and Initialization

Declaring a static array requires you to specify its type, name, and size. The size must be a constant value known at compile time. This is because the compiler needs to reserve a specific amount of space for the array.

// Declares an array named 'scores' that can hold 5 integers.
int scores[5];

// Declares an array named 'temperatures' that can hold 7 double values.
double temperatures[7];

You can initialize an array when you declare it using a list of values in curly braces. If you provide an initializer list, you can even let the compiler figure out the size for you.

// Declare and initialize an array of 5 integers.
int scores[5] = {94, 88, 72, 91, 85};

// The compiler deduces the size of the array is 3.
char grades[] = {'A', 'C', 'B'};

// A common technique to initialize a large array to all zeros.
double prices[10] = {0.0};

To work with the data in an array, you access elements using an index. C++ uses , which means the first element is at index 0, the second at index 1, and so on. The last element's index is always one less than the array's size.

int scores[5] = {94, 88, 72, 91, 85};

// Access the first element (at index 0)
int first_score = scores[0]; // first_score is 94

// Modify the third element (at index 2)
scores[2] = 75; // The array is now {94, 88, 75, 91, 85}

// Access the last element
int last_score = scores[4]; // last_score is 85

Arrays in Memory

When you declare a static array inside a function, it's allocated on the . The key feature of an array's memory layout is that it's a single, contiguous block. The elements are stored one after another, with no gaps. This direct layout is extremely efficient. The processor can quickly calculate the memory address of any element, which allows for very fast access.

You can determine the total memory an array occupies using the sizeof operator. Dividing the total size of the array by the size of one of its elements is a common C-style trick to calculate the number of elements.

#include <iostream>

int main() {
    int scores[] = {10, 20, 30, 40, 50, 60};

    // sizeof(scores) gives the total bytes of the array.
    // On most systems, an int is 4 bytes, so this will be 6 * 4 = 24.
    size_t total_size = sizeof(scores);
    std::cout << "Total array size: " << total_size << " bytes" << std::endl;

    // sizeof(int) gives the bytes of a single integer (usually 4).
    size_t element_size = sizeof(int);
    std::cout << "Size of one element: " << element_size << " bytes" << std::endl;

    // Divide total size by element size to get the count.
    size_t num_elements = total_size / element_size;
    std::cout << "Number of elements: " << num_elements << std::endl;

    return 0;
}

The Dangers of Fixed Size

The rigid nature of static arrays comes with significant risks. The biggest one is the complete lack of bounds checking. C++ trusts you to know the size of your array and to stay within its limits. If you try to access an element at an index that doesn't exist, the language won't stop you.

#include <iostream>

int main() {
    int data[3] = {100, 200, 300};

    // The valid indices are 0, 1, and 2.
    // Accessing index 3 is out of bounds!
    std::cout << data[3] << std::endl;

    // Writing to an out-of-bounds index is even worse.
    // This corrupts memory that doesn't belong to the array.
    data[4] = 999;

    return 0;
}

Accessing memory outside an array's bounds leads to . This means anything can happen. Your program might crash immediately, it might silently corrupt other variables, or it might appear to work correctly, only to fail later in a completely unrelated part of the code. These bugs, known as buffer overflows, are notoriously difficult to track down and can create serious security vulnerabilities.

The main limitation of static arrays is their fixed size. You must know exactly how much data you need to store when you write the code. This makes them unsuitable for situations where the amount of data can change, like reading user input or fetching data from a network.

Think you've got it? Let's check your understanding.

Quiz Questions 1/6

What is the defining characteristic of a C++ static array's size?

Quiz Questions 2/6

Given the declaration int scores[5] = {88, 92, 75, 100, 95};, which statement correctly accesses the value 75?

Advanced C++ Array Implementation