You know how to create variables and how to change the values of those variables a little, but this does not suffice when trying to programming a major application (trivial statement of the century). This section will introduce some basic elements of C++ which are found in all other programming languages.

The first construct we will cover is conditional statements. A conditional statement is an expression that has a result of either true or false, and code is executed depending on the result. We use conditional statements in English. Consider the following

  1. If Joe has a truck then buy Joe some pliers.

  2. If Rachel has a house then go to Rachel's house, if not, go to 
       Rachel's parents' house instead.

  3. If QP7 is going to Denver University and Beowulf is going to 
       Denver University, Then buy QP7 and Beowulf a TV/VCR combo;  
       if not, then figure something else out instead.

In C++, we use the if statement for the test-clause and the else statement for the else-clause. The syntax looks like this:

if(test-clause) result-clause
else else-clause

We will usually use the logical comparison operators in the test-clause. Just remember that if the test-clause evaluates to true (or non-zero) then the result-clause is executed, and if the test-clause evealuates to false (or zero) then the else-clause is executed if one is present. Example:

  int x = 10;
  int y = 11;
  int result;

  if(x == y) result=1;
  else result=0;

  char bob='b';
  int lowercase_letter;

  if( (bob >= 'a') && (bob <= 'z') ) lowercase_letter=1;
  else lowercase_letter=0 

If a variable may be one of several values, and we want to do something different for each of several values that that variable might be, then we can use a different kind of conditional statement called the switch expression. The switch expression calls for the name of the variable we are testing followed by several case statements. The syntax looks like this:

switch(variable-name) {
    case value1: expression1 break;
    case value2: expression2 break;
    case value3: expression3 break;
    ...
    default: else-clause break;
}

We're testing a variable against several values, or cases, as they are called here. We test a value against the variable by supplying one after the case statement. We follow the value with a colon, and give the code which is executed in result to that case being true. We don't use {} braces for the executed code, but instead use the break statement after the expression is executed. If we don't include the break statement, the next case is executed, which is usually undesirable and can have distasterous results. The default case is like the else statement in an if expression. The else-clause is executed if none of the cases are met. Lets try an example to see if this makes anything more clear.

  int GPA = 3;
  char grade;

  switch(GPA) {
    case 4: grade = 'A';
            break;
    case 3: grade = 'B';
            break;
    case 2: grade = 'C';
            break;
    case 1: grade = 'D';
            break;
    case 0: grade = 'F';
            break;
    default: grade = '?';
            break;
  }

A fundamental construct of all programming languages is the loop. A loop defines a section of code that is executed over and over again until certian expressions are met. There are two kinds of loops in C++: condtional and for loops. for loops are really a type of conditional loop, but since it uses a different syntax.

for loops have three sections in which it is declared:

  1. The variable(s) which will be used in the loop
  2. The condition for while that must be met for the loop to continue looping
  3. The way the variable(s) change on each cycle through the loop.

  int i;
  int val = 0;

  for( i=0; i<=100; i++ ) {
    val += 5;
  }

  char c;
  int  numletters = 0;

  for( c='A'; c<='Z'; c++ ) {
    numletters++;
  }

The for loop is based on an index variable paired with a while statement usually based on that index variable. C++ also provides functionality for a loop that is based only on a conditional statement. There are two types of loops that fall under this category: the while loop and the do...while loop. A while loop tests a conditional statement, and if this conditional statement is true, then it runs the loop until it is false. A do...while loop is very similar, except that it runs the loop, and then tests the conditional statement. If the statement is true, then it runs the loop again. The difference between a while and a do...while loop is that a do...while loop always runs the loop at least once.

The syntax for the while loop is as follows:

while (conditional-statment) {
   ...
   loop body
   ...
}

The syntax for the do...while loop is quite similar.

do {
   ...
   loop body
   ...
} while (conditional-statement);

It would be hard to present a practical example for these types of loops without first presenting methods of interfacing with the user, but we will cover this in later sections.

Functions represent the flow of the C++ program. Imagine a function as a task that you have to do, whether it be cleaning the house, emailing a friend, or doing your homework. As you go about your life, you decide you want to perform a task, and you follow the procedure in your head to complete the task. Functions in C++ consist of code that defines a task, and you can use this code over and over by calling the function. For instance, say we have the above three tasks in the form of C++ functions: clean_house, email_friend, and do_homework. These functions would be "called" from the main program, thier code would be executed, and the flow would return to the main program. The main program, however, is a function itself, called the main procedure. The program always starts its execution with the main procedure and ends it's execution when the main procedure ends. Other functions are called from the main procedure, and eventually return back to where they were called. Functions are called from within other functions, and when they are done, they return to the function that called it. Let's demonstrate this process using some pseudo-code:

// clean_house function definiton
clean_house {
  disponse_of_junk
  dust_wood_furniture
  vacuume
}

// email_friend function definition
email_friend {
  open_email_program
  type_email
  send
}

// do_homework function definition
do_homework {
  do_calculus
  do_physics
  do_engineering
  do_shakespeare
}

// main procedure function definiton
main function {
  // ! start of program
  call clean_house
  call email_friend
  call do_homework
  // ! end of program
}

Our program starts with the main function (the main procedure). From within the main procedure, the clean_house function is called, which picks up the junk, dusts the wooden furniture, and vacuumes. After the clean_house function is called, the program returns to the main procedure. The email_friend and do_homework functions are called from the main procedure likewise. This is basically how the flow of a normal program goes.

In a C++ program, functions must be declared before they are called. You can define them before the main procedure (where the program starts and ends), and then you can call them in the main procedure, but this is sometimes hard to read. This is the method I used in the above pseudo-code program. A clearer way to write a program is to have the function declarations, also called the function prototypes above the main procedure, and put the function definitions below the main procedure. It is very important that you now understand the difference between a function declaration and a function definition, because we use a slightly different syntax for the two. Let's start out with the syntax of a function declaration (or a function protype) and an example.

return-type function-name (parameter-type parameter-name, ...);

int add(int opperand1, int opperand2);

A few things to note about this. The function returns an integer to where it was called from, and expects two parameters, which are both integers. When the program calls the add() function, the two numbers that are going to be added are passed to the function, and their sum is returned.

We have declared this function, but we have not yet defined it. This means that the program knows that there is an add() function, but it doesn't know what it does because we haven't told it. If we tried to call the add() function without definining it somewhere in the program, we would not be able to compile the program. So what we need to do next is define the function, which is not too hard to do.

int add(int opperand1, int opperand2) {
     int sum = opperand1 + opperand2;
     return sum;
}

When we pass values to the function, the variables in the parameter list of the function become local variables in the function definition. The paradigm in this add() function is to create a local variable called sum, and assign to it the sum of the opperand1 and opperand2 (which are passed to the function). Then we return sum using the return statement. Let's look at the whole program to demonstrate where everything in placed and how the sum is returned to the calling function.

int add(int opperand1, int opperand2);

void main() {
     int total;
     total = add(10, 20);
}

int add(int opperand1, int opperand2) {
     int sum = opperand1 + opperand2;
     return sum;
}

The first line in the code example is the prototype (the declaration) for the add() function. This tells the program that an add function exists and how the program will call it, but not what it does. We have to write the function prototype before it is called.

After the add() prototype comes the main procedure. The void before the main() is the return type, which is nothing. Putting void for a return type tells the program that the function does not return a value. The () after 'main' tells the program that the main procedure does not excpet any parameters. Recall that the main procedure is where program execution begins and ends. A couple questions are probably in your mind: How can the main procedure return a value?, and how can the main procedure have parameters? Think of it this way: when you run your program, the opperating system (dos, windows, unix, os/2, etc) calls the main procedure. So the main procedure actually can return a value, and it is returned to the opperating system. The opperating system does not usually do anything with this returned value, but for debugging purposes it can indicate an error status. The main procedure can also accept parameters, and these come from the opperating system also. For many programs that you have probably seen, you can have a parameter list (also known as an argument list) for the program. For example, if you want to run Microsoft Word with the name of a Word document after the name of the program as follows:

C:\>WORD QUIZ.DOC

Then Quiz.Doc is opened up in Word. In Windows95, you can drag the icon for a document on to the Microsoft Word icon, and Word will open up with that program. The name of the program is an parameter to the main procedure in the code for Microsoft word! We will get into how the main function actually deals with these arguments later in this tutorial.

Back to our code example. In the main procedure an integer called 'total' is created. in this example we are using the add() function to compute the sum of 10 and 20, and then assign the sum to 'total'. When the program comes across the line

total = add(10, 20);

That's really all there is to say about functions: functions are just a block of code that perform some task and return a value to the place where it was called. I'll be using functions extensively for the remainder of this tutorial, so it is essential that you understand them now.

Up to this point if you have tried to most of the programs they have failed. With all compilers, you write C++ code in a source file (usually a .cpp or .cp file), tell the program to compile it, and an executable will be generated (an .exe or .com on the PC platform). There is more than just typing in the code--it has to be in a format that the compiler can recognize. Here is a list of guidelines that I will make reference to throughout this section and that you should keep in mind for the rest of the tutorial.

1. All executable statements should be inside a function
2. Preprocessor directives are placed at the top of the file before any user code.
3. Header files should contain no executable code (just declarations)

void FunctionOne() {
  int x;
}

void FunctionTwo() {
  int y;
}

The Class scope will be covered in the next chapters when we cover classes in detail. If a variable is declared outside of any function, it is said to have a File scope, meaning that it can be accessed from anywhere in the file. So you wonder, if we can create variables that can be accessed from anywhere in the file so easily, why not just declare all of our variables at the top of the program and not worry about scope? This is a bad idea for three reasons that scream out immediately from any programmer's mind. One, you can only use each variable name once, so eventually you will have to do what is called name mangling, meaning that you put a number or a letter at the end of a variable name to distinguish it from another (like counter1, counter2, name_a, name_b, etc). If you declare variables mostly on the block scope, then you can use the same variable name in different block scopes and not have to worry about masking the value of a variable in a higher scope (more on this shortly). Two, variables are organized by scope to give the reader of your code a hint as to where it is used. If you've got a function that has a for loop in it, it would be much better to define that variable at the block scope to tell the reader that it is going to be used in the block scope. Three, it's a waste of memory to declare all variables on the global scope because all global variables must be loaded up when the program loads up. When a variable goes out of scope, the memory it used is freed up so the rest of the program can use it. For instance, an integer variable consumes two bytes of RAM. If we know that we're going to have to use, say, fifty integers in a given program, and we declare them all globally, then the program has to reserve 100 bytes of RAM when it starts up. On the other hand, say we have five procedures and we can put ten of the integers we need in each of these procedures. Then the program would only require 20 bytes of RAM while it is running! More available RAM means better performance! Of course, this is an over simplification, and if we're only using integers in a program then we won't have to worry too much about conserving memory, but if we're writing a big program will gadzillions of variables, we'll want to place them in the block scopes that they are being used in. There is a time when we'll need to use global variables, but not all the time.

Finally, variables can be declared on the global scope, meaning that they can be accessed from anywhere in the program. The difference between file and global scope is that you can only access variables declared at the file scope from within that source code file (a source code file usually has the extension .cpp or .cp). Since a program may have several .cpp or .cp files, it may be beneficial to declare a variable as global to all source files. You do this using the extern keyword preceeding the variable declaration, which just tells the compiler, "Hey! This variable is declared here, but defined in another file, so it can be used in any file." Here's an example:

  extern int x;         // global variable
  extern double hi();   // global function

2. Preprocessor directives are placed at the top of the file before any user code. In C++, you don't have to write all the code. That's right--the hard workers at Microsoft, Borland, Watcom, Symantec (or whoever you bought your compiler from) have already written what is known as the standard C++ libraries and put them on your computer when you installed your compiler. All programming languages provide features for printing text to the screen, writing to files, and most provide functionality for graphics programming, databases, and windows/mac OS programming. The only way you can do anything with C++ is if you use C++ libraries, which come with your compiler and which you can also make when you get better at the language. A library is defined as a set of commands that have a common purpose. For instance, the C++ I/O Stream library provides commands for printing text to the screen, writing to files, and printing to the printer. The C++ String library provides string manipulation functions; Console I/O provides functions for manipulating a DOS-style console, and the Windows library provides (many) functions for writing windows program (API calls--for your Windows programmers). Every library has what is called a header file (some have several) in which all the declarations for the classes and functions that are used in the library are contained. Note that you usually don't get the source code for a library--you just get the header file. To use a library in your program, you simply #include the header file in the source file (.cpp or .c) you want to use it in. You do this using the #include preprocessor directive. A preprocessor directive is a command that is executed first in compilation, and do special things to the program such as defining global symbols that set flags, include header files, disable warnings, and provide special if...then statements that can take out blocks of code before the source code is even compiled! All preprocessor directives start with a #. For now all you need to be concerned with is #include, which we'll take a look at right now.

Say we want to print some text on the screen. Rather than writing assembly code to load the address of a string into the DX register, loading function 09h into the AH register and calling interrupt 21h, we'll just let the C++ I/O stream libraries do this work for us.

#include < iostream.h >

main() {
  cout << "Hello World!" << endl;
  return 0;
}

A stream is a place where data can be sent to or retrieved from, and represents the flow of data from one physical part of the computer to another. Some examples of streams are the printer, the console (screen), the auxillary port, the keyboard, and an error handler. You write to a stream by using the << opperator, and read from a stream using the >> opperator. You'll see plenty of uses for this in the next chapter where I cover programming techniques in depth.

At any rate, most preprocessor directives should come at the top of the file, and then comes the executable code.

3. Header files should contain no executable code (just declarations). We talked about using existing libraries by including their header files in part 2, but you can also create your own header files where you keep commonly used declarations. For future reference, keep in mind that header files should contain no executable code (or else they cannot be precompiled), so the only thing that should be written in header files are declarations and classes. You'll see the full power of writing your own header files in the next two chapters when you learn how to design projects, classes, and libraries.

There are a lot of compilers out there, and nobody wants to read pages upon pages of compiler specific information on an internet tutorial. One person reading this tutorial may be using Borland C++ 4.5, while another may be using Microsoft Visual C++ 4.0, while yet another may be using Symantec C++ for the Macintosh. To describe in detail how to opperate a program that many readers may not have would be pointless and a waste of many people's time. It isn't an easy task to learn how to create projects, how to manage these projects, debug them, and compile them, however. I am going to leave it up to you, the programmer, to learn how to use the compiler you bought. It undoubtedly has pages of reference on how to compile your programs and group source files together in a project. My job is to teach you how to program software, not how to use it. I propose that, if I have enough time, I will write an appendix to this tutorial that covers all such compiler-specific information.

1. Review the above material and make sure you understand anything you were iffy on the first time you read it, because in the next chapter you will be held responsible for this information (for the most part)
2. Learn how to use your compiler. A good test is to copy and paste the above Hello World program into a source file and see if you can get an output from it.