Memory, input and output

scanf()

The scanf() function reads the values of variables from the keyboard. It's format statement is similar to printf()'s.

Consider a specific example:

• We have two int variables j and k, both initialised to zero.
• We wish to use scanf() to read in an integer and assign that value to j.
• The user types in the value "3".

The scanf() function must:

1. Read the number "3" from the keyboard
2. Write the value "3" onto j's index card (so that when we next go to read the value of j we will read 3, not zero).

• How do we tell scanf() what card to write to?

Were it not for the peek-ahead in a previous lesson our first attempt to read j might look this:

    printf("Please enter an integer\n");
  scanf("%d", j); // ERROR

C always passes values of mathematical expressions to functions, never variables.

In this flawed example all we are passing to the scanf() function is the value of j, the number 0. Thus scanf() does not know which of the variables j and k we wish it to change, as the only information it has been given is "zero" and there are two variables with that value.. (Obviously the scanf() function cannot see our code to know what we are trying to do as the function comes with the compiler and was written long before we wrote our program.)

We can see this in its complete context below, where we have also shown the index cards used to store the values of j and k:

  #include <stdio.h>

int main() { 
  int j = 0, k = 0;
     
  printf("j and k are: %d %d\n", j, k);
  
  printf("Please enter an integer\n");
  scanf("%d", j); // ERROR
  
  printf("%d %d\n", j, k);
  
  return 0;
}

Step through this code

Questions:

NB: the answer to the first of these questions is very simple but incredibly important!

Given that passing the value of j does not tell scanf() which index card to write the new value on, what do we tell it?

1. Looking at the above figure of the code and its data what number must we pass to scanf() so it knows which card to write the value "3" to change the value of j?
   
2. What do you think is the meaning of &j in scanf("%d", &j);?
   

The computer stores the values of its variables in its memory

Some Horrible History

In the very early days of computers, programs were written in an extremely low-level syntax called machine code. There were no variable names and programmers had to manually keep track of what data was stored where. Locations were identified by numerical address, just like our index cards, and the programmer would have to think in terms like:

The notation float@12 is an example of something called pseudo-code. Pseudo-code is something that isn't actually valid but is just there to explain something. We shall use this particular pseudo-code quite a lot.

If we use the notation "float@12" for "the floating-point number stored in location 12" then this might have been coded (with comments) as:

 float@12 = 83.2;                  // mass
 float@16 = 4.1;                   // acceleration
 float@4 = float@12 * float@16;    // force
	      

Obviously, such programs were rather hard to understand: one big problem was simply remembering which value was stored at which location.

The invention of the compiler allowed the programmer to give programmer-friendly names to the individual memory locations . The compiler also took care of the job of deciding which memory location was given which name to avoid the danger of the programmer accidentally using the same location twice. This allowed the above instructions to be rewritten as something like:

 float mass, acceleration,
  force;
		     
 mass = 83.2;
 acceleration = 4.1;
 force = mass * acceleration;

 # Store mass at 12, acceleration
 # at 16 and force at 4, as floats
		       
 float@12 = 83.2;
 float@16 = 4.1;
 float@4 = float@12 * float@16;

The compiled executable is the same as before but the original source code was much easier for the programmer to understand.

The "location number" above is referred to as the variable's address and is a very important concept. If we know the address (and type) of a variable we can access and change its value, bypassing the programmer-friendly name altogether.

1. Study the above example
2. To understand how the computer treats variables and stores data.
   
1. Spend a few minutes studying this simple example to satisfy yourself that the "compiled pseudo-code" version does what we expect.

The concept of data's address becomes extremely important in the next few lessons.

An update to our memory model

So far we have presented a simple model of a human computer executing our instructions and writing the variable values on numbered index cards. The memory model of the actual computers we use is very similar and almost as simple (some would say too simple, as we shall see in the next lecture).

Computer programs store their temporary, "running" data in the computer's memory (RAM - for Random Access Memory). The computer's memory is measured in bytes and we can think of it being arranged in one huge block with its bytes numbered 1, 2, ...  4381712, etc..

Typically it takes four bytes to store an int, so when the computer encounters a line like:

int i, j;

it reserves two chunks of four bytes each to store the values of these two variables:

              -------------------------------------------------
Byte number:  | 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 |
              -------------------------------------------------
Used for:     | <-------- i --------> | <-------- j --------> |
              -------------------------------------------------

Here we have shown i and j as being stored next to each other, but the computer is under no obligation to do so.

The location where the variable is stored in memory is then the address of the variable. In the above example the variable i has the address of 400. In our "card index" model of our data this value is also the address of the index card (which is why doubles always have an address which is a multiple of 8). There is no variable with address 401, but that doesn't matter, as the compiler has set aside bytes 400-403 inclusive to use for storing the value of i. From now on whenever the compiler encounters the name i it will replace it by int@400 and it will replace j by int@404.

Strictly speaking at the compiler assigns the variable an address to be added to an offset to be determined when the function starts running, but we shall ignore this distinction most of the time.

A variable name is just a programmer-friendly name for the contents of a particular part of the computer's memory.

As we shall see in the following mini-exercise this has the side-effect of making our program almost impossible to understand!

1. View the Humanly and Computer executable versions
2. To cement our understanding of how the computer treats variables and stores data.
1. Open the following link in a new window: "total cost" program version 2
   You will see a new option at the top of the code, currently set to "Program view".
2. Click on "Next step" so that the index cards with the data values appear.
3. Now toggle between "Programmmer view" and "Combined view".
   • How much more difficult is the program to understand when we switch from "Program view" to "Combined view"?
     -- Choose an answer -- No more difficult A little more difficult Quite a lot more difficult A lot more difficult Hugely more difficult
4. Run through the code several times in "Combined view". (You can reset the program by reloadig the page.) Notice how in each case the "comined" variable name tells you which card the data is written on, as well as whattype it is.
5. Finally, choose "Computer view" and run through the code again until you are satisfied that all three views do exactly the same thing.
   • How much more difficult is the program to understand when we switch from "Program view" to "Computer view"?
     -- Choose an answer -- No more difficult A little more difficult Quite a lot more difficult A lot more difficult Hugely more difficult

The instructions generated by the compiler contain only constants and the memory addresses of variables, to access the values of variables the compiler generates instructions to read from or write to those addresses.

An update to the stepper

So far the C program stepper has just shown us the index-card model. variables and their values. It can also show us a visualisation of the computer's memory. We illustrate this in the example below where for the time being we will show both the table and the memory map, although in future we will normally just print out the memory map.

int main() {
  int j, k;

  printf("Value of j?\n");
  scanf("%d", &j);
  k = j + 3;

  return 0;
}

Step through this code


      

• Compare index-cards and the memory table
• To see how our index-card model leads on to how the computer stores its data.
• Open up the above "stepper link in a separate window so you can see both it and these instructions at the same time.
• 
  
• 
  
• 
  
• 
  
• 
  

&i tells us where the variable i is stored in memory

C has an operator for (almost) everything and if we ever want to know where a particular variable is stored in memory then C provides the & operator and even a printf() format %p to go with it:

  printf("i has the value %d and is stored at %p\n", i, &i);

In our example, the above code would print out the value of i followed by its address (location in memory) which is "400", although it would almost certainly print it out in hexadecimal. It's most unlikely you'll ever need to do this.

The & operator can tell us the address of a variable, i.e. where it is being stored, which allows us to bypass the "programmer-friendly" variable name altogether.

The type determines how many bytes are read and how to interpret them

If a variable is a float the computer will have to retrieve four bytes of memory, if it is a double it will retrieve eight bytes. Less obviously, it will interpret the 32 bits it retrieves for a four-byte int differently from those of a four-byte float.

For an integer variable one bit is used for the sign of the number and the remaining bits for its absolute value.
Floating-point numbers are stored in a base-2 version of scientific notation, i.e. instead of coefficient * 10^exponent they are stored as coefficient * 2^exponent (A 4-byte float uses 8 bits for the exponent and a 64-bit double 11 bits, with the remaining bits used for the coefficient.)

An Intel processor stores the number 7 in binary as follows:
7 stored as an int:    00000111 00000000 00000000 00000000
7 stored as a float:    00000000 00000000 11100000 01000000
Whilst we never need to know those values we can see that they are different. It turns out that if we write 7 as a float but mistakenly read it as an int the processor will interpret that as 1088421888. If we write 7 as an int but read it in as a float the processor will interpret it as 9.80909e-45.

Thus it's not enough to know the address of something in memory: in order to be able to use that address we have to tell the compiler the type of the object that is stored there.

The value of a variable is the binary contents of the memory stored at the address of that variable interpreted according to the type of that variable.

For a variable x the expression &x is said to point to x and the memory address of an object whose type is known is referred to as a pointer expression.

Mistakes with memory addresses

It follows that we can make two basic mistakes when using a memory address: we can use the wrong value or we can use the correct value but tell the compiler it points the the wrong type. We will see both of these below when we discuss errors with scanf().

Reading in variables with scanf()

We have already encountered the printf() statement, which can be used to print the value of variables to the screen:

  i = 1234;
  j = 5678;
  printf("The answers are: %d and %d\n", i, j);

C provides the scanf() function to do the opposite: to read in variables from the keyboard (or whatever the default input for our program is).

scanf() reads data from the keyboard.

scanf() is a "user-friendly" input function, it skips over spaces and new lines so if we are required to input two integers we could type in the two integers either both on the same line, or one on each line. Unlike printf() it's not normal to put any text in the format string, or \n at the end, if we want to read in two integers the format is just: "%d %d".

To read in more than one value just use the two individual formats separated by spaces such as "%d %d".  Do not put in commas or \n at the end.

So to read in two integers i and j from the keyboard we write:

scanf(), and its siblings are probably the only time you will ever need to use the "&" operator.

  printf("Please enter two integers  ");
  scanf("%d %d", &i, &j);

Step through this code

Note the &s - see below.

The above code will allow us to type in two integers and will set the values of i and j to the two values we have just typed.

Don't forget the the &

We always pass memory addresses to scanf() so variables which are arguments to scanf() must have an & in front of them: scanf("%d", &k);

By analogy with the printf() example above, our first attempt to use scanf() might have looked like this:

  i = 1234;
  j = 5678;
  scanf("%d %d", i, j);  /* Wrong! */

There's a big problem here, however. We have stressed that functions take arithmetic expressions as their arguments and that even if that expression is a single variable name as above, that variables can't have its value changed by the function.

As written above, the scanf()function can no more change the values of i and j than it can change the values of the mathematical constants "1234" and "5678". All that scanf() knows is that it was called with two arithmetic expressions for its arguments, one with the value 1234 and the other 5678.This is an example of using the wrong memory address: the computer will go to locations 1234 and 5678 and try to write an int to each location, which will almost certainly crash the program.

By using the & operator we are telling scanf() not the values of i and j but where they are stored in the computer's memory. In the example at the top, we are passing the values 400 and 404, not 1234 and 5678.

Companies that deliver washing machines will take away your old one (for an extra charge) There's no point in telling the delivery company "I'm not going to tell you the address to deliver the new one to, just that the old machine is a broken-down washing machine with the serial number xyz. They need to know the address to deliver it to, not the model (value) of the existing machine.

there are about 1 billion domestic washing machines world-wide, which is the same as the number of double-precision floating-point numbers our lab PCs can hold in their memory. So telling scanf() the existing value of a variable rather than it's address is equivalent to telling a delivery company: "Somewhere in the world is a broken washing machine with a specific serial number but not where it is!

Knowing the address and type of something is much more powerful than just knowing its value as it allows us not only to know its value but also to change it.

The format to read a double is "%lg"

This is one of the rare exceptions to C's helpful rule of treating all floating-point operations as double. It does this because it has no choice. Consider the following:

#include <stdio.h>

int main() {
  float littlevar; // Four bytes 
  double bigvar;   // Eight bytes 

  printf("Please enter two numbers:\n");
  scanf("%g", &littlevar);
  scanf("%lg", &bigvar);

  printf("%g %g\n", littlevar, bigvar);

  return 0;
}

Step through this code

The first call to scanf() requires us to read in a number and then write that number into the four bytes starting at the address (memory location) of littlevar, the second writes eight bytes to the memory location of bigvar. Since all scanf() is told about littlevar and bigvar is their memory addresses, which are just numbers, we have to tell it what they are the addresses of.

The format to read a double is "%lg".

Checking the arguments to scanf()

The scanf() function is unusual in that the number of arguments depends on the format string. Thus scanf() is not protected by C's usual prototype argument checking as its prototype just says its arguments are a character string possibly followed by other arguments of unknown type. If we give scanf() the address of a float when it needs the address of an int, or get the number of arguments wrong then things will go very badly wrong indeed (see the example below).

Turning on advanced argument checking

The compiler we use can understand format strings and check we have provided the correct number and type of arguments if we turn on the advanced options: -Wall -Werror . The first of these warns us, and is enabled by default in the on-line compiler.  The second causes the compiler to treat warnings and errors and refuse to go any further). Thus if you use your own computer we strongly recommend you  enable advanced warnings.

If we get formats wrong

In the following example we have used %g instead of %lg:

// This has a deliberate error: we are 
// using %g  to read bigvar instead of %lg
#include <stdio.h>

int main() {
  float littlevar = 0; // Four bytes 
  double bigvar = 0;   // Eight bytes

  printf("Please enter two numbers:\n");
  scanf("%g", &littlevar);
  scanf("%g", &bigvar); // ERROR!

  printf("%g %g\n", littlevar, bigvar);

  return 0;
}

Step through this code

We now only write write four bytes into where bigvar is stored, leaving the other four bytes unchanged. A typical run looks like:

Please enter two numbers:
4.56
7.89
4.56 6.9532e-310

We can see that the value of the double variable is essentially random.

The reason the values are so extreme is that bits that were written as being part of the coefficient are read as being part of the exponent and vice-versa.

Confusing %d and %g

Using the wrong format for the variable type will always produce major problems. The following horrific example first confuses %d and %g, "accidentally" using them for a float and int respectively. Finally we do something even worse: we use %lg for a float thus writing eight bytes into the location of a four-byte object. This has the effect of trashing the variable stored after it.

// This has deliberate error in all the formats
int main() {
  int j = 5, k;
  float floatvar = 0;

  printf("Please enter some numbers:\n");
  scanf("%d", &floatvar);
  scanf("%d", &floatvar);
  scanf("%g", &k);

  k = 10;
  scanf("%lg", &floatvar);

  scanf("%lg", &k);
  printf("%g %d\n", floatvar, j); 

  return 0;
}

Step through this code

 

The compiler can warn about us errors in scanf() - make sure you enable the checks!

When pointers attack: right value but the wrong type

This is the first in a number of examples in these lectures where making mistakes in our handling of computers memory using pointer expressions leads to strange errors and random behaviour. In this case we have given scanf() the correct memory addresses but have made a mistake in saying what type of object it is the address of.

Looking ahead

Writing to, and reading from, files

So far, we have always written to the standard output or stdout for short which is usually the terminal window. Similarly scanf() reads from standard input or stdin for short, usually the keyboard.

Reading from, or writing to, files on the computer is very similar once we have opened the file we wish to read from or write to.

We shall show some individual code fragments first followed by a couple of short complete examples.

Opening a file

The fopen() function opens a file for reading ("r") or writing ("w"). Note Opening an existing file for writing over-writes what was already there so there is also an append option ("a") which is like writing but appends it to the existing content.

  FILE *infile;

  infile = fopen("input.txt", "r");

(See below for a discussion about the "FILE *" variable.)

fopen("myfile.txt", "r") opens "myfile.txt" for reading. Use "w" to write to a file or "a" to add to the end of it.

Reading and writing from and to files

Once we have opened a file we can use the fscanf() and fprintf() functions read from, or write to, that file . They behave exactly like scanf() and printf() except for a "file" argument immediately before the format.

  fscanf(infile, "%d", &input);
  printf("The value is %d\n", input);

fscanf() and fprintf()behave exactly like scanf() and printf() except for a "FILE *" argument immediately before the format.

Closing the file

The fclose() function closes a file when we've finished with it. (All files are automatically closed for us when the program finishes.)

  fclose(infile);

Example

As an example, let us revisit our "Hello, world" program, this time making it write to a file:

/*
 * "Hello world" - to a file!
 */
#include <stdio.h>

int main() {
  FILE *outfile;

  /* Open a file for writing */
  outfile = fopen("helloworld.txt", "w");

  fprintf(outfile, "Hello, world\n");

  fclose(outfile);

  return 0;
}

The first thing we see is the highlighted FILE * variable called outfile. The precise meaning of FILE * varies from system to system and is defined in stdio.h; but whatever system we are using we can always use FILE * and it will mean the right thing for that system.

Don't forget the *! We shall see in a later lecture that this signifies a variable whose value is the memory address of something else.

We then open the file using fopen(). The first argument to fopen() is the name of the file we wish to open. This is the only time we use the name of the file, after that we just refer to it using the variable outfile. The second argument to fopen() tells the system how we want to use the file; "w" means to write to the file, over-writing any existing contents of the file, if any. We could also have used "a" to append our new data after the existing contents of the file. As mentioned above, "r" is used for reading.

We then just use fprintf() to write to the file. This is exactly the same as printf() except for the additional first argument which is the FILE * variable, outfile, not the file name.

Finally, we close the file, again using outfile, not the file name. This step is optional in this case, as the program is about to exit anyway.

The only time we use the name of the file is as an argument to fopen(). All other functions take the FILE * variable as an argument.

What if we can't open the file? - NULL and exit()

Our program has a weakness in that when it tries to open the file "helloworld.txt" it doesn't check to see if the call to fopen() failed. This might be because the disk was full, for example, or because we are trying to create a file inside a directory (or "folder" in Mac-speak) we don't have permission to write to.

This raises two questions: "How do we know if fopen() failed?" and "what do we do if it does?".

If fopen() fails it returns the special value NULL, defined in stdio.h. We can then test for failure using:

  if ( outfile == NULL ) ... /* We could not open the file */

return returns from that function, exit() exits from the whole program.

What we choose to do then this will vary according to our program but the simplest thing is just to print a warning message and exit from the program. We can do this from inside any function, not just main(), by calling the exit() function with an integer argument. This is defined inside the #include file stdlib.h ; the first time we have used this file. Just as when we return from main(), the convention is to use non-zero for failure.

We demonstrate this by making our code into a function:

#include <stdio.h>
#include <stdlib.h>

/*
 * Write "Hello world" - to a file, exiting on failure
 */
void writehello() {
  FILE *outfile;

  outfile = fopen("helloworld.txt", "w");
  if ( outfile == NULL ) {
    printf("I cannot open the file\n");
    exit(1);
  }

  fprintf(outfile, "Hello, world\n");

  fclose(outfile);
}

Always check to see if fopen() returns NULL and if so take appropriate action.

Reading from a file with fscanf()

This works in exactly the same way:

/*
 * Read an integer from a file
 */
#include <stdio.h>
#include <stdlib.h>

int main() {
  int input;
  FILE *infile;

  infile = fopen("input.txt", "r");
  if ( infile == NULL ) {
    printf("I cannot open the file\n");
    exit(1);
  }
  fscanf(infile, "%d", &input);
  printf("The value is %d\n", input);

  /* Do something interesting */

  fclose(infile);
  return 0;
}

It's worth noticing here that since we are inside main() we could have used either exit() or return. Also notice how we have been slightly paranoid by printing out the value of input immediately after we have read it. This is a good idea!

How do we know when we have run out of input?

When reading data from a file, we may not know in advance exactly how many data values there are in there. Fortunately C makes it easy for us as scanf() and fscanf() both return the number of values they have successfully read in or a special value called EOF if they have reached the end of the file. This allows us to write simple loops such as:

  while ( fscanf(infile, "%d", &i) == 1 ) {
    ... /* Do something interesting with i */
  }

Had we been reading in two data values we would have checked that fscanf() had returned the value 2:

  while ( fscanf(infile, "%d %d", &i,  &j) == 2 ) {
    ... /* Do something even more interesting with i and j */
  }

This tends to a be a lot easier that, say, writing the number of data values at the start of the file. It's much less useful when reading from the screen as scanf() just assumes it's waiting for the user to type the numbers in.

scanf() and fscanf() return the number of values they have successfully read in. This can be extremely useful as the control of a while() loop.

The three defaults: stdin, stdout and stderr

stdin is used for input

stdout is used for output

stderr is used for errors, warnings and diagnostics

  if (infile == NULL ) {
    fprintf(stderr, "I cannot open the file\n");
    exit(1);
  }

is better than using printf("I cannot open the file\n") .

Normally stdout and stderr both go to the terminal window but they can be sent to different places.

We won't penalise you for sending all your error messages to stdout using printf() but you should be aware that it's better practice to use stderr.

stdin reads from standard input, stdout writes to standard output and stderr writes to standard error. Eg:
fscanf(stdin, "%d", &k) is the same as scanf("%d", &k)
fprintf(stdin, "%d\n", k) is the same as printf("%d\n", k)

Checking for valid input

Often we need to read in some values that must be in a particular range, or satisfy some other criteria. If the data is invalid the worst thing we can do is to just let the program carry on with the wrong data.

Always check input is valid and do something helpful rather than just carry on.

Error checking is tedious but necessary.

The wider the program's user-base the better the error checking must be.

A program we will only be using ourselves can expect the user to be reasonably tolerant if it crashes when we enter the wrong number. A program people pay to use will have to be very tolerant of its users!

It is better to have a few standard techniques we use as often as possible than for every case to be treated differently.

Example: noughts and crosses

Consider the example of a player entering the co-ordinates of the square they wish to play into a noughts and crosses program. The person is quite likely to make a mistake but would like the chance to fix it. We might start off by writing something like this:

   printf("Please enter the x and y coordinates in the range 1-3 ");
   scanf("%d %d", &x, &y);

This fine assuming the user hasn't made a mistake. There are two basic mistakes they may make:

1. The co-ordinates of square might be outside of the range one to three. (An invalid square.)
2. The square may have valid co-ordinates but already have been played.

It would be very irritating to be playing noughts and crosses and the program to quit or crash becasue we entered "4" when we meant to type "3", or if the square had already been played. So we need the program to handle this reasonably gracefully and to give the user a chance to correct their error. Notice too that there are two possible errors and it would be nice to print a different message for each one.

Approaches to handling the wrong input

There are two possible ways of handling the situation when a users enters an invalid square into noughts and crosses:

1. We could simply accept the numbers and pass them onto the rest of the program. The problem with this is that it becomes very difficult to recover the situation when the program discovers the input is incorrect.
2. We could enclose our scanf() inside a loop, immediately check the input is valid and only exit the loop when it is. We then end up with a piece of code that reads in data and guarantees it is valid. This has two advantages:
   1. It's much easier as it's completely self-contained.
   2. Although it's a bit of effort the first time it gives us a "recipe" that we can use in any situation just by changing the error test(s) and diagnostic message(s).

This suggests a reasonable course of action when reading data would be to put our scanf() statement inside a loop and:

1. Check the input for validity.
2. Check for each possible error in turn and if it's wrong print a helpful error message exlaining what the problem is and try again.
3. Advanced: After a few failed attempts just give up and exit the program. (See later.)

Infinite loops and the break statement

The break statement breaks out of the innermost switch() statement or loop (but not an if()).

Infinite loops

We've previously stressed the importance of accidentally creating infinite loops, but the break statement gives us the chance to use them positively, using a construction such as:

  while ( 1 == 1 ) {
    ....
    if ( everything_is_ok )
      break;
  }

Putting it together

Consider our noughts and crosses program and imagine we have already written a function squareisplayed() to tell us if a square has already been played. We can put our scanf() statement inside a loop as follows:

//
// Demonstrate the break statement as part of a noughts and crosses program
//
#include <stdio.h>

int squareisplayed(int x, int y); // Written elsewhere

int main() {
  int x, y;

  printf("Welcome to the noughts and crosses program\n");

  while ( 1 == 1 ) {
    printf("Please enter the x and y coordinates in the range 1-3 ");
    scanf("%d %d", &x, &y);

    if ( x < 1 || x > 3 || y < 1 || y > 3  ) 
      printf("\nThe inputs are in the wrong range, please try again.\n\n");
    else if ( squareisplayed(x, y) )
      printf("\nSorry, the square (%i, %i) has already been played\n", x, y);
    else
      break;
  }

  printf("Your move is: (%d, %d)\n", x, y);
  return 0;
}

Step through this code

Notice the logic here: we look for each possible error in turn (invalid square, or square already played). If one error condition is true the appropriate part of if() is triggered and a message is printed. Control passes to the end of the if() and immediately hits the end of the loop which then repeats.

Only if none of the "wrong data" tests is true does the program reach "else" branch containing the break and the loop quits.

If any of the error tests is true the message will get printed, the rest of the if will be skipped and the program will hit the end of the loop and go round again. Only if all of the error tests fail with the break statement be reached and the look exit.

Variation: an infinite for(;;) loop

Another popular way to write an infinite loop is to use an infinite for(;;):

for (;;) {
  ... 
}

Note we have still got the two semi-colons inside the for(;;).

This works because in a for() loop if the test is absent it is assumed to be true. The apparent weakness of this construction (it looks strange!) is also its strength: it look so strange it's hard to mistake it for anything else.

This loop forms the basis of our optional better input loop.

The next time you are running one of your programs that expects you to type in a number try typing a letter instead! What happens? We shall deal with this in a later program.

When reading data from the keyboard check it's valid and if not print an error message and give the user another chance.