The structure of C programs

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

/* Compile this program with:
   cc -std=c11 -Wall -Werror -o rotate rotate.c
 */

#define ROT 13

static char rotate(char c)
{
    c = c + ROT;
    .....
    return c;
}

int main(int argcount, char *argvalue[])
{
    // check the number of arguments
    if(argcount != 2) {
        ....
        exit(EXIT_FAILURE);
    }
    else {
        ....
        exit(EXIT_SUCCESS);
    }
    return 0;
}

The structure of C programs, continued

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

/* Compile this program with:
   cc -std=c11 -Wall -Werror -o rotate rotate.c
 */

#define ROT 13

static char rotate(char c)
{
    c = c + ROT;
    .....
    return c;
}

int main(int argcount, char *argvalue[])
{ 
    // check the number of arguments
    if(argcount != 2) {
        ....
        exit(EXIT_FAILURE);
    }
    else {
        ....
        exit(EXIT_SUCCESS);
    }
    return 0;
}

Compiling and linking our C programs

Variables

Naming our variables

• While variable names can be almost anything (but not the same as the keywords in C) there's a simple restriction on the permitted characters in a name -
  • they must commence with an alphabetic or the underscore character (_ A-Z a-z), and
  • be followed by zero or more alphabetic, underscore or digit characters (_ A-Z a-z 0-9).

• C variable names are case sensitive, thus:
  MYLIMIT,  mylimit,  Mylimit  and  MyLimit
  are four different variable names.

• While not required, it's preferred that variable names do not consist entirely of uppercase characters.
  We'll consistently use uppercase-only names for constants provided by the C preprocessor, or user-defined type names:
  MAXLENGTH,  AVATAR,  BUFSIZ,  and  ROT

• Older C compilers limited variable names to, say, 8 unique characters. Thus, for them,
  turn_nuclear_reactor_coolant_on    and    turn_nuclear_reactor_coolant_off
  are the same variable! Keep this in mind if ever developing portable code for old environments.

Basic datatypes

The Significance of Integers in C

At a low level, different manufacturers employed different memory sizes for a basic character - some just 6 bits, some 8 bits, 9, and 10. The unfortunate outcome was the incompatability of computer programs and data storage formats.

The C programming language, developed in the early 1970s, addressed this issue by not defining the required size of its datatypes. Thus, C programs are portable at the level of their source code - porting a program to a different computer architecture is possible, provided that the programs are compiled on (or for) each architecture. The only requirement was that:

sizeof(char) ≤ sizeof(short) ≤ sizeof(int) ≤ sizeof(long)

Since the 1980s, fortunately, the industry has agreed on 8-bit characters or bytes. But (compiling and) running the C program on different architectures:

#include <stdio.h>

int main(void)
{
    printf("char  %lu\n", sizeof(char));
    printf("short %lu\n", sizeof(short));
    printf("int   %lu\n", sizeof(int));
    printf("long  %lu\n", sizeof(long));
    return 0;
}

char  1
short 2
int   4
long  8

Why does this matter? Different sized integers can store different maximum values - the above datatypes are signed (supporting positive and negative values) so a 4-byte integer can only represent the values -2,147,483,648 to 2,147,483,647.

If employing integers for 'simple' counting, or looping over a known range of values, there's rarely a problem. But if using integers to count many (small) values, such as milli- or micro-seconds, it matters:

• Fun fact: GPS uses 10 bits to store the week. That means it runs out... oh heck ? April 6, 2019
• Airlines Have To Reboot Their Airbus A350 Planes After Every 149 Hours
• To keep a Boeing Dreamliner flying, reboot once every 248 days

The scope of variables

• global scope (sometimes termed file scope) in which variables are declared outside of all functions and statement blocks, and

• block scope in which variables are declared within a function or statement block.

01  #include <stdio.h>
02  #include <stdlib.h>
03  #include <string.h>
04  #include <ctype.h>
05
06  static int count = 0;
07
08  int main(int argcount, char *argvalue[])
09  {
10      int nfound = 0;
11
12      // check the number of arguments
13      if(argcount != 2) {
14          int nerrors = 1;
15
16          ....
17          exit(EXIT_FAILURE);
18      }
19      else {
20          int ntimes = 100;
21
22          ....
23          exit(EXIT_SUCCESS);
24      }
25      return 0;
26  }

Flow of control in a C program

• C programs commence their execution at their main() function, execute their statements, and exit (return the flow of control) to the operating system.

• It's fairly obvious that statements need to be executed in a well-defined order, as we expect programs to always behave the same way (unless some random data directs the execution path, as in computer games, simulations, and heuristic algorithms).

• Default flow of control executes each statement in order, top-to-bottom.

• Programs that only execute from top-to-bottom are pretty boring, and we need to control their flow with a variety of conditional statements, loops, and function-calls.

Conditional execution

if(condition1) {                
  // more statements;
  .....
}
else {
  // more statements;
  .....
}

if(condition1) {                
  // more statements;
  .....
}

if(condition1) {                
  // more statements;
  .....
}
else if(condition2) {
  // more statements;
  .....
}
else {
  // more statements;
  .....
}

Boolean values

int initialised = 0; // set to false
....

if(! initialised) {                
  // initialisation statements;
  .....
  initialised = 1; // set to true
}

int initialised = 0; // set to false
....

if(initialised = 0) {                
  // initialisation statements;
  .....
  initialised = 1; // set to true
}

int initialised = 0; // set to false
....

if(0 = initialised) { // invalid syntax!
  // initialisation statements;
  .....
  initialised = 1; // set to true
}

    while( (nextch = getc(file) ) != EOF ) {....

  #include <stdbool.h>

Switch statements

if(expression == value1) {
  // more statements;
  .....
}
else if(expression == value2) {
  // more statements;
  .....
}
else {
  // more statements;
  .....
}

switch (expression) {          
  case value1 :
  // more statements;
    .....
    break;

  case value2 :
    // more statements;
    .....
    break;

  default :
    // more statements;
    .....
    break;
}

switch (expression) {
  case value1 :
  case value2 :
    // handle either value1 or value2
    .....
    break;

  case value3 :
    // more statements;
    .....
    // no 'break' statement, drop through

  default :
    // more statements;
    .....
    break;

}

• Typically the 'expression' is simply an identifier, but it may be arbitrarily complex - such as an arithmetic expression, or a function call.
• The datatype of the 'expression' must be an integer (which includes characters, Booleans, and enumerated types), but it cannot be a real or floating-point datatype.
• The break statement at the end of each case indicates that we have finished with the 'current' value, and control-flow leaves the switch statement.
  Without a break statement, control-flow continues "downwards", flowing into the next case branch (even though the expression does not have that case's value!).
• switch statements with 'dense' values (none, or few integer missing) provide good opportunities for optimised code.
• There is no need to introduce a new block, with curly-brackets, unless you need to define new local variables for specific case branches.

Flow of control in a C program - bounded loops

// here, variable i holds the values 1,2,...10

for(int i = 1 ; i <= 10 ; i = i+1) {
// the above introduced a loop-control variable, i
  .....
  printf("loop number %i\n", i);
  .....
// variable i is available down to here
}

// but variable i is not available from here

// here, variable ch holds each lowercase value

for(char ch = 'a' ; ch <= 'z' ; ch = ch+1) {
  .....
  printf("loop using character '%c'\n", ch);
  .....
}

Flow of control in a C program - unbounded loops

#define  NLOOPS    20

int i = 1;
int n = 0;
 .....

while(i <= NLOOPS) {
    printf("iteration number %i\n", i);
    .....
    .....
    i = some_calculation_setting_i;
    n = n + 1;
}

printf("loop was traversed %i times\n", n);

#define  NLOOPS    20

int i = 1;
int n = 0;
 .....

do {
    printf("iteration number %i\n", i);
    .....
    .....
    i = some_calculation_setting_i;
    n = n + 1;
} while(i <= NLOOPS);

printf("loop was traversed %i times\n", n);

Writing loops within loops

#define  NROWS     6
#define  NCOLS     4

for(int row = 1 ; row <= NROWS ; row = row+1) {      // the 'outer' loop

    for(int col = 1 ; col <= NCOLS ; col = col+1) {  // the 'inner' loop
        printf("(%i,%i)  ", row, col);               // print row and col as if "coordinates"  
    }
    printf("\n");                                    // finish printing on this line
}

    (1,1)  (1,2)  (1,3)  (1,4)  
    (2,1)  (2,2)  (2,3)  (2,4)  
    (3,1)  (3,2)  (3,3)  (3,4)  
    (4,1)  (4,2)  (4,3)  (4,4)  
    (5,1)  (5,2)  (5,3)  (5,4)  
    (6,1)  (6,2)  (6,3)  (6,4)

Notice that we have two distinct loop-control variables, row and col.

• for loops within for loops,
• while loops within while loops,
• for loops within while loops,
• and so on....

Changing the regular flow of control within loops

for(int i = 1 ; i <= 10 ; i = i+1) {
    // Read an input character from the keyboard
    .....
    if(input_char == 'Q') { // Should we quit?
        break;
    }
    .....
    .....
}
// Come here after the 'break'.  i is unavailable

for(char ch = 'a' ; ch <= 'z' ; ch = ch+1) {
    if(ch == 'm') { // skip over the character 'm'
        continue;
    }
    .....
    .....
    statements that will never see ch == 'm'
    .....
    .....
}

The equivalence of bounded and unbounded loops

for( expression1 ; expression2 ; expression3 ) {
    statement1;
    ....
}

expression1;                                         
while(expression2) {
    statement1;
    ....
    expression3;
}

Some unusual loops you will encounter

for(int i = 1 ; /* condition is missing */ ; i = i+1) {
    .....
    .....
}

// cryptic - avoid this mechanism
for( ; ; ) {
    .....
    .....
}

#include <stdbool.h>

// clearer - use this mechanism
while( true ) {
    .....
    .....
}

Lecture Summary

• C11 is a small programming language (in terms of its number of keywords), although some aspects can be difficult to learn when compared to newer languages.

• C is a compiled programming language. The human-readable source code of a C program needs translating to executable machine code before the program can be executed.

• Unlike Python programs, white-space is insignificant and is not used to define lexical scoping. New lexical blocks are introduced with curly brackets.

• Alphabetic case is significant. Any colour seen in textbooks or possibly (visually) added by your text editor, is insignificant.

• C provides a number of integer data types, of differing system-dependent widths, and two floating-point data types. Data types of exact widths may be explictly specified for architecture-specific programming.

• Floating-point data types are only very rarely used in systems programming.

• C's control-flow statements - conditional statements, bounded and unbounded loops, and nested instances of these, and unconditional control-flow - execute similarly to equivalent statements in other languages, although their syntax may appear unusual.