An array is a named group of several consecutive variables of the same type. Each of the component variables is accessed from the array name and an index number.

Assume SIZE is an integer constant:

The following declaration creates three arrays, each consisting of three variables of type double:

We can initialize these arrays using a for loop. Be careful, array indices start at 0, so the maximum valid index is SIZE – 1 = 2:

Here is a picture of what's going on in the computer's memory:

We can add the entries in vec1 to the corresponding entries in vec2 and store them in vec3 using a for loop:

Another for loop prints vec3:

Producing the output:

We can introduce Vector as an alternative name for length three arrays of doubles by using a typedef declaration, but the syntax is a little tricky:

Now we can simply declare vec1, vec2, and vec3 as VECTORs:

We can also initialize arrays in their declarations:

Of course we can also define arrays of arrays. This might be a good way to represent matrices:

We need a nested for loop to initialize these:

Each row of one of our matrices is an ordinary array:

Write a program that prompts the user for the rows of a 3 X 3 matrix, then returns the determinant. (Check your math books for the definition of determinant.)

Each variable has a unique address in the computer's memory. We can discover the address of a variable x using the address of operator: &x. For example, on my computer executing the statements:

produces the output:

Addresses, also called pointers, are usually given in hexadecimal notation. Notice that difference between two consecutive pointers is 4. That's because on my computer:

If we change nums to an array of short ints, then the output produced is:

Differences between consecutive pointers is now 2 because on my computer:

Although pointers look like integers, they are not. For example, it's illegal to store an pointer in an integer variable:

Instead, pointers must be stored in pointer variables. The type of all pointers to ints is called int*:

The syntax of a pointer declaration is a little tricky. Officially, a declaration has four parts:

The specifier (e.g. const) and the initializer (e.g. = { 100, 200, 300 }) are optional. The base type is any valid C++ type name: int, float, vector<string>, etc. The declarator is a name and, optionally, some declarator operators. For example, recall the declaration of the nums array:

This declaration has no specifier. The base type is int, the initializer is = {100, 200, 300} and the declarator consists of the name, nums, and the declarator operator [3]. The syntax is complicated because it suggests nums is an integer variable, but that's not the case.

As it turns out, even though * appeared next to the base type in:

It is also a declarator operator. C++ simply ignores the spaces. We could have written:

This can cause problems. For example, if we attempt to declare two pointers, we can get in trouble:

The correct syntax is:

Here's a picture representing the definitions we have at this point:

There's more confusion to come. What can we do with a pointer? Two things. We can dereference a pointer. This means we can discover the value stored inside the variable it points to. What's confusing is the syntax. We use the same operator used to declare the pointer type:

Be careful. dereferencing a null pointer is the most common cause if programs crashing:

The value of a null pointer is 0, so a safe way to dereference is:

The other thing we can do is pointer arithmetic. For example:

Notice, incrementing a pointer by 1 really increments it by sizeof(int).

There is a close relationship between pointers and arrays: arrays are constant pointers. C++ translates the expression:

into:

Here's another way to traverse an array. Note the similarity with iterators:

Assume

Assume the following declarations are made:

Assume:

Compute the values produced by the following expressions:

Mixing the const specifier with pointer declarations creates four combinations. Assume the following declarations are made:

Here is what you can and can't do with these pointers:

The computer's memory is divided into four segments:

Local variables and parameters are allocated in the stack. Global variables are allocated in the static segment. Binary instructions are allocated in the code segment. The computer manages allocation and deallocation of variables in these segments, however, the programmer can allocate and deallocate variables in the heap segment while the program is running.

The new() operator allocates variables in the heap. It returns a pointer to the allocated variable:

The delete() operator deallocates heap variables so they can be reallocated later:

All of this would be pretty uninteresting if it weren't also possible to create array variables in the heap:

Use the delete[] operator to delete an array:

A heap array is also called a dynamic array because, unlike ordinary arrays, they can be expanded. For example, to add one more element to p we can write:

Arrays have two problems. First, C++ does not automatically validate indices. Instead, the program just crashes, or worse, memory is corrupted:

Second, arrays can't expand to accommodate more elements. A length three array is always a length three array.

To solve these problems the standard C++ library includes a vector class. Actually, vector is not a class, it's a template for generating classes. For example, here is how we would declare different types of vectors:

(Note the space after the second angle bracket in the middle declaration. This is necessary to prevent confusion with the right shift operator.)

We can add as many elements as we want to vec1:

We can access the members of vec1 using subscripts:

Unfortunately, the subscript operator, [], doesn't validate index bounds, we need the at() function encapsulated by vec1 for that:

To make vectors available to our programs, we must include the vector header file:

Officially, vectors, in fact all of the container templates, use iterators as abstract pointers. We aren't allowed to know what an iterator is, but here's how one is declared:

All vectors encapsulate iterators that point to the first element and just beyond the last element:

An iterator can be incremented or decremented using the ++ and -- operators. The element an iterator p points to can be accessed by dereferencing the iterator using the unary * operator. Putting all this together, here's another way to traverse vec1:

Here are some example declarations of character variables initialized by character literals. Notice that literal characters are bracketed by single quotes and that char is the name of the type of all characters:

Internally, a character is represented by an integer. For example:

prints 46 on my computer.

An appropriate integer can be converted into the character it represents. For example, the statement:

prints A on my computer.

Control characters represent special keys such as the return key, etc. They have special literal representations that use the backslash character:

The standard C library contains functions for classifying and manipulating characters. They are declared in <cctype>:

Here's a little program for determining character codes. Unfortunately, we'll have to make the user type <Ctrl> + c to break out of the loop:

Here's a sample output produced on my computer, which uses ASCII character codes:

A C string variable is simply an array of characters. To allow C strings of varying sizes, these arrays are often allocated in the heap:

A C string literal is a sequence of characters bracketed by double quotes. Backslash is the escape character:

C strings are always terminated by the NUL character, where NUL = char(0). The standard C library provides functions for manipulating C strings (see below).

Programmers should use C++ strings (see below) instead of C strings, because C strings don't check for out-of-range indices, and they don't allocate and deallocate memory for themselves. Instead, these jobs are left to the programmer.

There are several places where C strings are still used in C++. One example are command line arguments. The DOS console always passes the entire command line, including the command name, to main() as an array of C strings (i.e. an array of arrays of chars). The console also passes the length of this array to main().

Notice that although the executable is renamed, the new name is used in the error message:

The standard C++ library provides a string class declared in <string>. A C++ string is an object that encapsulates many useful functions. The program below demonstrates some of these functions.

The boldface text demonstrates the most important string operations:

An input file stream (ifstream) is a special kind of input stream (istream). This means all operations we can perform on input streams can also be performed on input file streams. The main trick is knowing that when an input file stream fails for any reason, the stream itself turns into 0.

We can construct an input file stream from a file name:

If the file isn't found or if its permission level doesn't allow reading, then ifs will enter the fail state and it is set equal to 0:

We can use the zero test again to determine when the end of the file is reached. This is more reliable than the eof() function, because that returns false even when only white space characters remain in the file:

For example, the following program computes the average of a file of numbers:

Of course if a non number is encountered in the file, even so much as a punctuation mark, the loop will exit and return the average of the numbers seen.

An output file stream (ofstream) is a special kind of output stream (ostream). This means any operations we can perform on an output stream can also be performed on an output file stream.

Everyone's favorite file function changes lower case letters to upper case letters. I'm using the toupper() function defined in the standard C library, so I need to include <cctype>:

Counting words and lines in a file is harder than you'd think. I increment my word counter each time I encounter a non letter following a letter. If the last character in the file was a letter, I increment my word counter again. I increment my line counter each time I encounter a newline character. If the last character in the file was not a newline, I increment my line count once more. Can you think of other improvements?

Grep is a famous UNIX utility that searches a given file line-by-line for a given pattern. It prints lines, with their line numbers, that contain the pattern. The ultimate pattern matching algorithm is the subject of an upper division algorithms course. I simply use the find() function encapsulated by string objects. Note that command line arguments are used to get the pattern and file name. This function also uses the standard library's getline() function to fetch an entire line and put it into a string variable:

Notice that all of these functions depend on the fact that get(), getline(), and >> return the stream as a value after each extraction.

Assume we are interested in describing the distribution of a set of test scores: s₁, ..., s_n. The center of the distribution is given by the mean:

The spread of the scores is given by the standard deviation:

The variance is the average variation:

The variation of the ith score is the square of its difference from the mean:

Write a program that prompts the user for a file of test scores, then computes and prints the mean, minimum score, maximum score, and standard variation.