Arrays

An array is a collection of elements of the same type placed in contiguous memory locations, referred to by a single variable name. Consider storing the scores of 20 students: doing it with 20 separate variables quickly becomes unmanageable, and scaling that approach to 1000 students turns into a long, repetitive block of declarations and input statements.

An array solves this by allocating one block of memory for the whole group, with each element reached through its position, called the index or subscript.

An array must be declared before use, just like an ordinary variable:

In C++, indexing always starts at 0, so an array of size n is indexed from 0 to n−1. num[0] is read as “num zero” — a shorthand for “the num array subscripted by zero.”

The memory reserved for an array depends on its type and size:

Elements sit at consecutive addresses — e.g. a 4-byte integer array starting at address 1000 places num[0] at 1000–1003, num[1] at 1004–1007, and so on.

Elements can be initialised at declaration, with the values listed inside braces:

Values are stored in the order written — the first fills index 0, the second fills index 1, and so on. If fewer values are given than the declared size, the remaining numeric elements are set to 0 (a char array pads with the space character ' ' instead). When an initialiser list is present, the size itself can be omitted and is inferred from the count of values:

An individual element is reached with the array name and a subscript — a variable, constant, or any integer expression:

Using a loop control variable as the subscript is far more scalable, letting a single statement step through every element in sequence:

Traversal means visiting every element of an array at least once to perform some operation — displaying all elements, summing them, or finding the largest are all examples. Program 2.1 below reads five scores and prints them back in reverse, by running the index from 4 down to 0:

To find the largest element, a variable is initialised to the first element and then compared against each remaining element in turn, replacing itself whenever a larger value turns up — try this and the reverse-order display in the workbench below.

A string is a sequence of characters, but C++ has no fundamental data type built specifically to hold one. A single char variable can only ever store one character, so a name like "Niketh" — six characters — needs a char array instead:

Unlike arrays of other types, a character array enjoys a special privilege: once declared, its name behaves like an ordinary string variable, so cin >> my_name; reads a whole word into it in one statement — this shortcut does not work for arrays of int or float.

When a string is stored in a character array, C++ automatically appends a null character '\0' right after the last letter, marking where the string ends. So the memory needed for a string is always one byte more than its visible length — "Niketh" has six letters but occupies seven bytes.

A character array can also be initialised directly from a string literal, and if the size is left unspecified it is inferred from the string's length plus one byte for the terminator:

Reading a string with cin >> my_name; works only until a space appears — cin treats white space as a separator between data items. So an input like "Maya Mohan" is read as two separate items, and only "Maya" ends up stored.

C++ provides two console functions, declared in <cstdio>, that work around this limitation:

Even though a string is normally handled as a whole with cin/cout or gets/puts, any individual character can still be reached by its subscript — my_name[0] is the first letter, and the terminating '\0' can be located the same way. Program 2.6 uses exactly this to count vowels, iterating with a for loop until the null character is reached:

Note the deliberate absence of a break after each vowel case — since every matching case does the same thing, they simply fall through to the single shared statement.