One important difference between C++ and most other languages (at least ones that I've worked with) is how you tell the computer what kind of thing you're going to be reading out of the file, i.e. is it a character file? Is it a number file? Well, it turns out that in C++ you don't really tell it until you get the info from the file. The way that it knows is by looking at what kind of variable you read the file stream into. You can switch variable types in mid-file, which is very useful for databasing with file entries of mixed types.

int c;
ifstream infile ("filename.txt");
infile >> c;

         And a quick example to show off file I/O:

#include < iostream.h >
#include < fstream.h >

main() {
  ifstream infile ("filename.txt");  // listing file name in declaration automatically
                                     // opens the file.  If you don't do this, you have
                                     // to call the function infile.open("filename.txt")
  if (!infile) {
    cout << "File 'filename.txt' doesn't exist!" << endl;
    return 1;     // returns an error condition of 1.
  }

  char c;               // declare c as a character
  cout << "Copying 'filename.txt' to 'filename.bak'...";

  ofstream outfile("filename.bak");

  infile >> c;
  while (infile) {              // this slightly strange construct checks for 
                                // the end of the file gracefully.
    outfile << c;
    infile >> c;
  }

  infile.close();
  outfile.close();

  cout << "done." << endl;
}

Variables

         Variables are very straightforward in C++. The types that you'll use most frequently (with their sizes) are:

char (1 byte)
short (2 bytes)
int (2-4 bytes depending on compiler)
long (4 bytes)
long long (8 bytes)
float (8 bytes)
double (10 bytes)

         Additionally, you can declare all the integer types as either signed or unsigned (signed is the default). A couple of special notes, however, that you're going to want to know about:

char c;
int i;
cin >> c;
i = c;
cout << i;

float result;
int input;
cin >> input;
result = input/15;
cout << result;

result = input/15.0;

         One of the very handy things about C++ is that you can initialize variables as you declare them (by default all initial values are "undefined" -- that means "random"). If you want it to have a value when you declare it, here's how:

int c = 0;

Conditional execution

         C++ has three ways to do conditional execution (that I can think of right now). The three ways are 'if', 'switch', and ':?' -- the only ternary operator in C++.

         The 'if' statement is really easy. Suppose you get this number from the user, and you want to know if they entered something greater than 10. The following code will test and act on this:

cin >> a;
if (a>10) {
	cout << "What you entered is greater than 10!  Die!" << endl;
}
else {
	cout << "What you entered is less than or equal to 10!  Die!" << endl;
}

         And so this is very easy. The expression to evaluate has to be enclosed in parentheses, but other than that almost everything else about the if construct is optional. If you have only one statement to execute, you don't need the curly braces. You never have to put an else construct in there at all. The parsing skeleton for the 'if' statement looks like this:

if () {
	;
}
[ 
else if () {
	;
}
]
[
else {
	;
}
]

         The next way to do conditional execution is the 'switch' statement. The 'switch' statement is really useful only for a large number of conditional blocks, like choosing what number the user entered on a menu. Since having 10 layers of nested if statements is ugly and hard to debug, the switch is a very useful alternative. Here's the general form of a switch statement:

switch (< expression >) {
	case < constant >:
      < statements >
      break;
	case < constant >:
      < statements >
      break;
	.
	.
	default:
      < statements >
      break;
}

         You have to be very careful with the switch statement, though, because as soon as it finds one of the case statements that match the expression, it will execute until it hits a 'break' statement. The compiler won't catch it if you don't put it in, because there are situations in which you want multiple numbers to run the same code.

         The final conditional construct is C++'s only ternary operator. It works exactly like an if/else statement with only one line on each part. Here's an example:

c = a < b ? 0 : 1 ;

         Which is the same as:

if ( a < b )
	c = 0;
else 
	c = 1;

         ..but as you can see, the code is much smaller, and harder to read. This comes in handy once in a while, but is fairly rare until you get to the guru level and deal with people who love this stuff (like me!). (By the way, this particular segment of code could be optimized with "c = a>=b".)

Loops

         Looping is a very important part of programming because there are many things that you want to do on consecutive data. There are three ways to loop (that I can think of right now): for, while, and do.

         'for' is the most common loop. It is not like the for loops of other languages, however, because it is really a while in disguise. Here's the general format, and then an example:

for ( < initial statements > ; < conditional evaluation > ; < incremental statements >) {
	< statements >
	.
	.
}

// loop to calculate the sum of the numbers 1 through 10:
int result = 0;
int i;
for (i = 1; i<=10; i=i+1)
	result = result + i;

         There are some compactions to that code that I have to go over now, because you'll see them everywhere. First, the "i=i+1" has a nifty shortcut in C++. Since you could have outrageously long variable names, and you just want to increase it by 3, you'd normally have to type it twice. So, there's an operator in C++ that looks like this: +=. Instead of saying big_variable_name = big_variable_name + 3; you can now type big_variable_name += 3. Furthermore, almost every operator in C++ can do this! So, the following are all legal operators: -=, *=, /=, %=, <<=, >>=. There's yet another shortcut for incrementing or decrementing by one: ++ and --. There are called the [pre|post][increment|decrement] operators. Instead of saying i+=1 you can now say i++ or ++i. (The difference between the pre and post is when you evaluate it vs when you do that actual increment -- cout << ++t won't say the same thing as cout << t++, but t will have the same value afterwards.)

         After compacting, the above code becomes this:

int result = 0;
for (int i = 1; i<=10; i++)
	result += i;

         Nifty, eh? It was the chair, eh... [Editor's note: I don't even remember what that was a reference to.]

Branches

         Branching doesn't really happen in C++, if you're used to things like BASIC's GOTO statement. What C++ has is functions, and that's about it. (There is inded a C++ goto, but I advise ignoring it because it's bad style and hard to debug. If, however, you're diehard for the goto statement, you have to say goto < label >, and the labels are declared on their own line followed by a colon.) So instead, here's how to do functions in C++.

         A function is usually coded before main(), because if you put it anywhere else you have to let the compiler know where it is, and since that's not nice I'm not getting into it right now. The general form of a function is:

< return type > function_name([< parameters >]) {
	< statements >
	.
	.
	return < return type variable > ;
}

         If you don't want a return type (i.e. a procedure, not a function) the return type is "void", and when you want to leave the function you execute "return;" without any parameter. The skeleton I gave above for general C++ programs is a pretty good display of how to use these, but here's an example anyways:

// returns the factorial of n.  This is a recursive function:
int factorial(int n) {
	if (n<=1)
		return 1;
	else
		return n*factorial(n-1);
}

         And when you're down in main() or wherever and you want to call it, all you have to say is

int result;
result = factorial(6);