Subscript numbering in C++ always starts at _________.

Arrays in C++ provide a way of storing a fixed-size collection of elements of the same data type. Imagine an array as a row of mailboxes, each holding a value, and importantly, all these mailboxes occupy adjacent positions. Due to this arrangement, arrays efficiently utilize memory and allow fast access to their elements. When you declare an array, like int myNumbers[5];, you're essentially asking for a block of memory that can hold five integers, lined up in a row.

The beauty of an array is that once you know the address of the first element (often called the base address), you can easily calculate the address of any other element just by knowing its position in the sequence. C++ does this calculation behind the scenes when you access an element using an index.

Indexing is the method used to specify the position of an element within an array in C++. It's like telling someone which mailbox to open to retrieve a specific letter. In C++, index numbering begins at 0, not 1. This is known as zero-based indexing and is a common convention in programming languages.

So in an array myNumbers[5]; with elements {10, 20, 30, 40, 50}, the element with the value 10 would be accessed as myNumbers[0] and the value 50 as myNumbers[4]. This might feel counterintuitive at first since humans often start counting from one, but it's a fundamental concept in C++ that enables certain optimizations and a standardized way to access memory.

Contiguous memory allocation refers to the way memory is set aside so that each element of the array directly follows the previous one. This linear arrangement means if you know the address of the first element, you can calculate the address of any element by adding the index to the base address - all due to the contiguous nature of the storage. For example, if your array's starting point (first element) is at memory address 200 and each integer takes up 4 bytes of memory, then the second element would be at address 204, the third at 208, and so on.

This system optimizes memory usage and processing speed because the system doesn't need to jump around to different memory locations when working with array elements. It can simply move from one adjacent space to the next, making operations like iteration over elements extremely efficient.