This introductory lecture contains a few rather simple programs. I wanted to select them as mostly typical for C/C++.

Following the traditions, let me start with a sort of "hello world!" code:

If you name this file as in a comment of the top line, the regular way to compile it and execute might be:

>g++ -c hello.cpp
>g++ -o hello hello.o
>hello

Although nothing special is in this code, it certainly contains a few elements, which could create a little discomfort for C programmers, and which are mostly unfamiliar for the Fortran world. The 1st line calls the standard library file, which is responsible for input/output (C counterpart: stdio.h). The main function is of the integer type, so, you need to return something. It does not take any argument here, and simply outputs a greeting on the display. The program invites you to enter a name from your keyboard (lines 6/8). Note, that we declare the name of the character type in line 5. It is declared as the char-type array. You may substitute the declaration of line 5 by char *name; with the same result.
For the C people: if you are conservative and prefer to use printf and scanf instead of cout and cin, just do it! Note: // means a line from a current position to its end is commented. A C-type comment /*...*/ is also available, and commonly used, if a comment involves a few sequential lines. And do not forget to put semicolumns at the ends of lines!

A general information about control statements.  C++ provides three types of loop controls: while, do/while, and for. The for control is as popular, as do/end do, or, do/continue in FORTRAN. Three selection controls include a single if structure,  a double selection if/else structure,  and multiple-selection switch structure.  No problems should arise from the first two. As for the last one, below please find modification of the "Hello" code, for which the switch structure is employed.

With using a request of C-function get() by the input object cin, i.e., name = cin.get(), one character from the keyboard is read and stored in integer variable name. EOF is a symbolic integer constant defined in iostream.h header file. On UNIX systems, EOF is entered by typing ctrl-d.

The most interesting in this program is how the switch structure works. It is enclosed within the while statement. I want to draw your attention to the fact, that all cases should be identified by integer numbers. In "Hello_1" the characters in, let say, line 14 are overloaded in integers. You can easily check this by inserting a new line between lines 15 and 16: cout << name << endl;. For "a" you will arrive at 97, for "A", at 65.

The next example "Roll-a-die" is also predominantly addressed to the Fortran world. It will show us, how the random number generator works. The loop structure for, strictly speaking, two for statements, will be a help, as well as the array of integer numbers frequency.

1. // roll_a_die.cpp


2. #include <iostream.h>


3. #include <stdlib.h>




5. main()


6. {


7.     int frequency[7] = {0}; /* number of the array elements 7, they are indexed


8.                              from 0 to 6. all 7 elements are initialized to zero. */






11.     cout << "Face" << " " << "Frequency" << endl; // header for the output


12.     // Roll a 6-sided die 1000 times...


13.     for (int attempt = 1; attempt <= 1000; attempt++)


14.     {


15.         int face = 1 + rand() % 6;


16.         ++frequency[face];


17.     }


18.     // output


19.     for (face = 1; face <= 6; face++)


20.         cout << " " << face << " " << frequency[face] << endl;




22.     return 0;


23. }

The output on your machine might be of the following kind:

Face     Frequency
   1           157
   2           177
   3           157
   4           161
   5           165
   6           183

If you execute this program repeatedly the output will be the same. So, it's possible to conclude that the random number generator creates pseudorandom numbers. That's right. The reason for this is that rand() function generates an integer between 0 and RAND_MAX, a symbolic int constant defined in stdlib.h. For two-byte integers this constant is at least 32767, for four-byte integers, 2147483647. So, that was a reason why for having the integers randomly distrubuted between 1 and 6, we used the modulus division, as in line 15. However, rand() always selects the same random number series. If you wish to get rid of such a restriction, use function srand(unsigned int). You will observe a little improvement, if you insert the following content at the lines 9 and 10:

   9. unsigned seed = 2001; // or, any other unsigned int number...
  10. srand(seed);

However, that's still far from being perfect. This time you get a sequence of random numbers different from that due to rand(). However, it's still deterministic: executing your program again you will arraive at the same series of random numbers. Note: srand(1) produces the output identical to rand(). One of the ways for escaping from such a "determinism" is to use the system function time(NULL). It causes the computer to read its clock to obtain the insigned int seed automatically. Its easy to make such a modification. You do not need line 9 anymore. Change line 10 like this

  10. srand(time(NULL));

and fill line 4 with the include statement, which is for activating time(NULL):

   4. #include <time.h>;

In "Roll-a-die" you meet with post- & pre-incrementing. In both cases, the integer number is incremented by 1, a difference can be briefly described as follows:
Let us suppose that currentNmb = 5. Then, currentNmb is, certainly, 6 after applying currentNmb++, and/or, ++currentNmb. If we consider someFunction(++currentNmb), it is someFunction(6), but someFunction(currentNmb++) is still someFunction(5).
Note, that the starting index of an array is 0.

Arrays and strings, which we briefly discussed above, are closely related to pointers. So, they should be introducted as well: A pointer is a variable that holds a memory address. Try this simple program:

1. // very_simple_pointer.cpp


2. #include <iostream.h>


3. main()


4. {


5.     int * ptrValue = 0;


6.     int value;


7.     value = 5;


8.     ptrValue = & value;


9.     cout << *ptrValue << endl;


10. return 0;


11. }

The pointer operator (*) is always used in a pointer declaration, and for dereferencing a pointer, as it is done in line 9. This last operation returns a value whose address the pointer holds.

Compiler returns an error in this case: Holding the address of value1, ptrValue cannot be changed to point to anything else. The value can be modified through ptrValue, but ptrValue always points to the same memory location. However, if your change looks like this

the program works properly. Now ptrValue points to const value, but can be changed itself. However, trying to modify the value, which pointer holds, like this

        *ptrValue = 100;

One of the most important pointer's task is to manage data on the free store. In C++ you allocate memory on the free store by using the new keyword. After finishing with managing data, you must call delete on the pointer. And remember that the free store is free, but its resources are limited, so, do not forget to check whether memory is available. In C a similar management is performed via the key words malloc and free.

1. // pointer_heap.cpp


2. #include <iostream.h>




4. main()


5. {


6.     int * ptrValue = new int;


7.     if (ptrValue == NULL)


8.     {


9.         cout << "Error! No memory for ptrValue!";


10.         return 0;


11.     }


12.     // look at the address, which pointer points to


13.     cout << ptrValue << endl;


14.     *ptrValue = 6;


15.     cout << *ptrValue << endl;


16.     delete ptrValue;


17.     return 0;


18. }

In lines 6-10 an elementary memory control is imposed. More sofisticated way for the memory control is to use assertion. In this case you should include the standard file

Then the conditional statement is simply replaced by

After checking that no memory problems arise, the address will be displayed due to line 12. In my desktop computer it was 0x00780DA0. In line 13 the dereferenced pointer is used to store data. Line 15 is our farewell to the pointer. After deleting it, be careful: do not use it again in the program.

A reference is an alias: creating a reference, you initialize it with target's name. From that moment on, the reference acts as an alternative name for the target, and anything you do to the reference is done to the target.

The output is easy to anticipate:

An easy rule for dealing with references: if you declare them, but do not initialize, a compile-time error comes.
The reference operator & is the same as that one used for the address, but they are different, although they are related.
The address of a reference is identical to that one of a target.
And do not re-assign a reference!

What should we know about functions is that
1) the return statement can return only one value
2) functions should be declared in accordance with their types.
3) function's arguments are not confined to values only: arguments may be passed by reference (using pointers, and/or, references) as well.
4) among other function's types there are analogs of procedures, or, subroutines in other languages: that is the type void.
5) if necessary, a function contains no arguments.

Let us consider now the swap function which performs a permutation of arguments by value. I draw your attention to the fact that the function should be declared and defined, like we did this with variables.

You will get the output, which looks like this:

In spite of our efforts to swap the variables, they remained unchanged. That is because local copies were made in the swap function. Let us look, what happens, if we pass the arguments by reference.

1. // swap_by_reference.cpp


2. #include <iostream.h>




4. void swap(int &, int &); // arguments: references




6. main()


7. {


8.     int x = 5, y = 7;


9.     cout << "In Main: Before swap: x = " << x << ", y = " << y << endl;


10.     swap(x, y);


11.     cout << "In Main: After swap: x = " << x << ", y = " << y << endl;




13.     return 0;


14. }




16. void swap (int &rX, int &rY)


17. {


18.     int tmpr;


19.     cout << "In Swap: Before swap: rX = " << rX << ", rY = " << rY << endl;


20.     tmpr = rX;


21.     rX = rY;


22.     rY = tmpr;


23.     cout << "In Swap: After swap: rX = " << rX << ", rY = " << rY << endl;


24.     // void: no return


25. }

Now you get the following output:

We reached our goal. The variables exchanged by their values. And this happened, because we manipulated with references. Remember, that references are aliases of corresponding variables? So, that was just our case: Manipulating with refrences, we did this with the original variables as well.

1. // swap_by_pointer.cpp


2. #include <iostream.h>




4. void swap(int *, int *) // arguments: pointers




6. main()


7. {


8.     int x = 5, y = 7;


9.     cout << "In Main: Before swap: x = " << x << ", y = " << y << endl;


10.     swap(&x, &y); // arguments: variable's addresses


11.     cout << "In Main: After swap: x = " << x << ", y = " << y << endl;




13.     return 0;


14. }

The program is not finished. So, it will be your exercize to complete it.

The final part of this Introductory Day involves a brief info about Recursive functions, Arrays, and Strings.

The Fibonacci Series in Recursion

There exist many modifications of this Series. The original set was proposed long time ago by italian mathematician Fibonacci. Now you can meet with the Fibonacci numbers in different sorts of applications, e.g., in biology, quantum chaos, etc.

Let us define the Fibonacci series recursively:

1. // fibonacci_with_recursion.cpp


2. #include <iostream.h>




4. unsigned long fibonacci(unsigned long); // type: int modification




6. main()


7. {


8.     unsigned long number;


9.     cout << "Enter an integer: ";


10.     cin >> number;


11.     cout << "Fibonacci(" << number << ") = "


12.             << fibonacci(number) << endl;


13.     return 0;


14. }




16. unsigned long fibonacci(unsigned long n)


17. {


18.     if (n == 0 || n == 1) // operator ||: or


19.         return n;


20.     else


21.         return fibonacci(n-1) + fibonacci(n-2);


22. }

An exercise for you again: try to right your own program, using the C++ syntax, which would determine the Fibonacci numbers iteratively.

A word of caution about recursive programs: each level of recursion in the example from above results in doubling of the number of variable calls. Although recursive procedures are very readable and well-organized, the number of calls, when executing, grows exponentially.

Arrays

For this moment let me confine to the syntax of arrays. Remember, when you declare the array like this
arrayType arr[arraySize];
the number of the array's elements is arraySize, but, they are enumerated from 0 to arraySize - 1. Does not matter, whether you initialize it at the step of declaration, or, later. If there are fewer initializers than elements in array, the remaining elements will be initialized to zero. If you need to initialized an array to zero, you may do it like this

Multiple-dimensional arrays I would like to illustrate in two dimensions. The array int z[2][3] may be interpreted as two-dimensional matrix where the second subscript is related to columns (from 0 to 2), and the first subscript to rows (from 0 to 1). Notice that the function definition specifies the parameters of the mentioned above array as int z[][3], for example, if function void printArray calls it, the syntax should be as follows:

A possible initialization of the array

might be re-written as follows

Pointers & Arrays: Relationship

the array name without a subscript is a pointer to the first element of the array.
For instance, if we declare pointer float * rPtr, we can set it to the address of the first element of array r with the statement

This is equivalent to

The pointer arithmetic definition is based on this analogy, for example, you may dereference the tenth element of the array with the pointer expression,

or, even like this

String as a Character Array

We met already with strings as character arrays, however, with no accompanying exlanations. Recall, in hello.cpp we declared string name as

This means that with the statement

we may store from a keyboard a character array capable of storing up to 79 characters and a terminating null. If I decide to store my name into that string, the structure of the character array will be as follows:

The meaningless part of the array is denoted by dots. Try a program echoo.cpp. It and its modifications are for visualizing a character array structure.

This program returns you a string, that you stored, as a vertical echo. Comment line 10 and uncomment line 11. The structure of a complete array, its meaning and meaningless parts, will be visualized.
    A popular mistake that people do with the strings: the number of stored characters coincides with stringLength. This does not leave any place for a terminating null.

Character arrays can be initialized by using the following feature of arrays: If the array size is omitted from a declaration with an initialized list, the number of elements in the array will be the number of elements in the initialized list. Let me illustrate this with my name again:

The array size is evidently 8. This kind of initialization can be done in a much easier manner:

Although the number of literal characters in name is 7, the length of name is 8 because of a terminating null.

Strings via Pointers

Initialization of my name can be also done with a variable of type char *:

This last declaration creates pointer variable namePtr that points to the string Gennady somewhere in memory.

Manipulating Strings

Here I collected an elementary information on how to manipulate strings with string library functions. First two are strcpy and strncpy. How they work is shown in copy.cpp:

Functions strcat and strncat append the second argument, a string, to its first argument, a character array. See the example below.

A couple of notes in connection with append.cpp: first, unsigned int and unsigned long types may be substituted by the size_t type, which is defined in the standard C library. Second, appending with strcat and strncat is accompanied by replacing a terminating null of the first argument by the first character of the second argument. A terminating null is appended to the result.

strlen is a function of int type. It returns the number of characters within a string: terminating null is not included.

Exersizes

1. Find errors, if they exist, in the following fragments:

2. Write a program, which will allow you to calculate factorial recursively.

3. What is a difference between two outputs? Make necessary corrections in the case of errors.

4. Define void swap(int *,int*) in swap_by_pointer.cpp.

5. Write a program, which will return the Fibonacci numbers iteratively.

6. Write a program, which will tokenize a string: "The introductory day of the C++ course is over".