The following scope rules answer the second question.

Let us illustrate these rules with the following example: In the program we defined two functions, one is the main function, and the other is the printVars function. Each function has an inner block in it. We defined some variables in each function and their nested blocks. We also declared a couple of global variables. All variables are initialized and their values supposed to stay unchanged during the execution of the program. Now let's try to analyze the output if the program:

The main function variables:
a = 3 (defined here)
b = 2
c = 4 (defined here)
Variables in the nested block in the main function:
a = 3
b = 2
c = 4
d = 5 (defined here)
The printVars function variables:
a = 1
b = 6 (defined here)
e = 7 (defined here)
Variables in the nested block in the printVars function:
a = 1
b = 9 (defined here)
e = 7
f = 8 (defined here)

One-dimensional arrays

Let us imagine that we need to create a program, which reads 4 integer numbers from the user, computes their average and dispersion. Dispersion is a square root of the sum of the square differences between each number, and the average divided by the quantity of the numbers. For example, if our numbers are a₁, a₂, a₃, and a₄, then the average will be

How to deal with arrays and their elements

Notation: can be considered as equivalent to But in the array case, we do not need to list all our elements and we can also access each element not only with constant index like: but also using an integer variable like in this example: Please notice that the very first element of the array has index 0, not 1. So, the very last element of 10-element array will have index 9. Using array we can easily modify example and make it usable for any number of integers:

It is useful to understand what happens when you declare an array in your program. If you define a 10-element integer array in your program, compiler allocates 10 times as many bytes as needed to keep one integer value and remembers the address of the very first element. All these allocated bytes are placed one after another in the memory so the compiler does not have to remember the location of each element. If you need to access the third element of the array (a[2]), then the compiler just computes the offset from the first element (it needs to take the address of the first element, which it remembers, and add two times the number of bytes for one element). For example, the program line int a[5] will correspond the following picture: There is one very important moment in this scheme: the compiler uses the specified size of the array only when it is allocating memory for it and forgets the size after that moment. That is, when the program runs you can actually use illegal indexes. For example, for the example above we can try to run Index 6 corresponds to the 7th element of the array but our array a - has only 5 elements in it. Nevertheless, the program will run this instruction using the algorithm described above. It will take the address of the first element then adds 6 times the number of bytes for one int (which is usually 4) and will put the new value at the computed location. Thus, we can accidentally change values of other variables without even knowing it. This program shows how this can be done. In particular, this means that it is your responsibility to take care of the indexes and check if they are inside legal ranges.

Initialization. Arrays as function arguments

We can initialize an array at the moment when we declare it, just the way we initialized usual variables: Notice that the number of the constants inside the curly brackets must match the size of the array. When the size of the array is relatively big, it can very annoying compute all these numbers on the right side of the assignment operator. To avoid this we can use a shorter form of array declaration. We don't have to specify the size of the array if we immediately assign values: This notation is equivalent to the one above. The compiler counts the numbers of constants on the right and allocates the required amount of memory automatically. Don't forget that this method can be used only when we initialize the array in the declaration instruction. We cannot write just and hope that compiler will guess the desired size of the array.

However, sometimes we can see the notation like this int a[] without size. This structure is used when we need to pass an array as an argument of a function. Let's consider an example of function that searches for the biggest element in an array: We can use the construction without array size here because we do not define an array here we just tell the compiler that the first argument of the function is not a usual variable but an array of integers. Here is a main that calls this function:

Pointers. Operators & and *

As we saw above, the compiler allocates memory for array. That is, we must specify the size of each array before compiling our program. Unfortunately, we not always know how big should our array be to satisfy users. It would be good to be able to allocate memory for arrays later when the program is already running and can figure these sizes out (ask the users, for example). C++ allows us to create so called dynamic arrays. But before explaining how to use them we need to explain the idea of pointer.

Assume, we declared the following variables: ,then the picture of the memory will look something like this where the addresses on the left are the numbers of the memory cells where these variables are stored. So , we can tell that variable a takes cells with numbers 10DC--10E0, variable ch takes cell number 10DB, etc. It's an old tradition use hexadecimal notation for memory addresses. In usual decimal notation the numbers will be:

Thus, if a variable addr contains an address of a particular memory cell, then the expression *addr gives us the value stored at this address. However, the big question is, how does the compiler know what value we are interested in, or in other words, at how many bytes it should look? Here we come to the idea of pointer. Pointer is an address that also contains information of what type of variable is located at this address. Pointer says, "I point to an integer value", or "a double value". To declare a pointer variable, we need to use the star operator: You can read this notation as "if an operator star is applied to an address contained in variable int_ptr, then the value is integer". That is, int_ptr is a pointer to an integer. The following code illustrates how we can access variable know its address: In this example, we define two integer variables a and b and a pointer to an integer ptr. At line 4, we initialize the pointer and from now on it points at the location of variable b. Line number 5 is the most important and confusing line of the code. Let's read it step by step.

Dynamic arrays also have another advantage over static arrays. The memory reserved for keeping their elements can be de-allocated during the program execution and can be used by other programs or other arrays in the same program. To free the memory of a no longer needed dynamic array, use operator delete. The general syntax for the delete operator is:

Combining different data types together. Defining new types.

Sometimes it's very convenient to treat a set of different variables together as one item. For example, if we need to remember a date, then we need to have a variable for day, variable for month, and a variable for year. Another example, as you saw above for every array we need to remember its size to check that our indexes are inside the legal range; that is, it's very convenient to keep an array (or a pointer for dynamic arrays) and its size as a single item. This convenience becomes necessity if we have a lot of similar data to work with, for example, a bunch of different dates, of a set of arrays.

C++ has a special structure that allows us to combine several variables together and treat them as one bigger variable. This structure is called struct. The general syntax is this:

struct VariableName {
   var_type var_name_1;
   var_type var_name_2;
   ...
   var_type var_name_N;
};

Now we do know how to define a new type that contains variables of several different types in it and how to declare variables of that type and initialize them. The only thing we need to know is how to extract information out of a structure, or, in other words, how to access every element inside a structure variable. A special operator . (dot) allows us to that. The general form is:

The following example will illustrate several things about structures. Please notice while you reading:

Exercises.

1. Create a new structured type IntArray for a dynamic array of integer numbers. This type should include a pointer to an integer and integer for size of the array.
2. Write a function printIntArray that takes a variable of IntArray type as an argument and print this array.
3. Write a function getIntArray that takes a variable of IntArray type as a changeable argument and does the following:
   1. asks the user how many number there will be in the array;
   2. checks the user's input for correctness;
   3. reserves the needed amount of memory (use operator new);
   4. reads all numbers from the user and puts them into the array.
4. Write a function maxInIntArray that takes an IntArray variable as its argument and returns the biggest element in the array.
5. Write a function minInIntArray that takes an IntArray variable as its argument and returns the smallest element in the array.
6. Write a program that combines all the previous parts together and reads an array from the user, prints it back, and also prints the max and min element of the array. Comment each function in your program, the new type, and the whole program itself.

References