while the name for the 10th item is:

Note that although we have 10,000 items, there is no "itemInventory[10000]" As a matter of fact, to write "itemInventory[10000]" in the program we are working on would likely cause serious problems because we would be accessing the first memory location past the end of the array. Thus, we declare our array using the value 10,000, meaning that there are 10,000 integer memory locations to set aside BUT we use subscript values in the range 0 to 9999.

At this point we know that each individual array element is a unique memory location and that the array name along with a subscript enclosed in brackets represents that memory location. Further, each individual array element is of some type - the type included in the array declaration. In other words, when one writes "itemInventory[3456]", one is referring to a specific integer. Therefore, "itemInventory[3456]" can be used ANYWHERE in a program that an integer can be used. The same is true for array elements of any type. We will see later, for example, that if we declare an array to hold elements of some class type, the elements of that array can be used anywhere instances of the class can be used.

B. Working with the Individual Elements
Let's start with simple examples involving our inventory array. Above, we said that the item codes for the items would range from 1 to 10000. To make this problem and our coding life easier, let's change that to read that the item codes range from 0 to 9999. Remember, this means that the first inventory item has the item code '0', the second has the item code '1', the third has the item code '2', etc.

Suppose we wanted to state that there are 20 items in the inventory with item code 4. We could write this as:

The code is the same as any other assignment statement, except for the subscript.

Or, suppose we wanted to add 1 to the first inventory item. We could now write this as:

If we wanted to read in a value and store that value in the location holding the amount for item code 22, we could write:

And, if later we wished to output the inventory count for that same item, we could write:

We can also use these elements in arithmetic expressions. Suppose, for example, that we wanted to find out the worth of our inventory for the item with item code 12. Remembering that we also have an array of item prices called 'itemPrices', we could calculate this using the code:

Likewise, we can use array elements in relational expressions. For example if would be legal to write:

if (itemInventory[342] < 2345)
{
// some code
}

or

Which inventory item gets the value 22? Or, which inventory item is to be output? We will see in a bit how to quickly output, for example, all the elements of an array

C. Variables as Indices
We are now ready to rewrite that ugly switch statement we saw above - the one with the 10,000 'cases' - to handle the 10,000 items in the inventory. The code for that statement included the line below to indicate that the inventory for item 9999 is being reduced by the amount sold ('itemSold'):

Remembering that item codes now start at 0 instead of 1 and that the item code for item 9999 would now be 9998, we can rewrite this as:

This by itself does not gain us much. However, there is no reason why our subscript values must be constants. It is perfectly legal for subscripts to be variables or even expressions (for example, var1 + var2) - as long as those expressions evaluate to integers. Subscripts must evaluate to integers because it is, of course, impossible to talk about the 2.5th element of an array.

Using the previous declaration for itemInventory and assuming that the individual items have been loaded with the correct inventory values, it would be perfectly legal to write the code:

int itemCode = 9998; // declare a variable and initialize its value to 9998
int itemSold;
cout << "Please enter the amount sold of the item with inventory number '9998'.
cin >> itemSold;
itemInventory[itemCode] -=itemSold;

Now we go one step further and ask the user for the item code. (In a store this information would be received from the device that reads bar codes at the check-out counter.).

int itemCode;
int itemSold;

cout << "Please enter the code for the item being sold.\n";
cin >> itemCode;

cout << "Please enter the amount sold.\n";
cin >> itemSold;

itemInventory[itemCode] -=itemSold;