enum eqnstatus { EQN_UNSOLVED, EQN_ONEROOT, EQN_REALROOTS,
EQN_COMPLEX_ROOTS };

enum eqnstatus { EQN_UNSOLVED, EQN_ONEROOT, EQN_REALROOTS,
EQN_COMPLEX_ROOTS };

main() {
  enum eqnstatus eqn_status = EQN_UNSOLVED;
}

#include <stdio.h>

typedef enum { VANILLA, CHOCOLATE, STRAWBERRY } Flavour;

typedef struct {
  Flavour flavour;
  float fat;
  float sugar;
  float calories;
} Icecream;

main() {
  Icecream icecream;

  icecream.flavour = CHOCOLATE;
  printf("%d\n", icecream.flavour); /* Prints: 1 */
}

typedef enum { VANILLA, CHOCOLATE, STRAWBERRY, NUM_FLAVOURS } Flavour;

typedef struct {
  Flavour flavour;
  float fat;
  float sugar;
  float calories;
} Icecream;

Icecream icecreams[NUM_FLAVOURS];

typedef enum { VANILLA, CHOCOLATE, STRAWBERRY, TOFFEE, NUM_FLAVOURS } Flavour;

enum something { TYPE1, TYPE2=76, TYPE3, TYPE4 };

When to use enumerations

Enumerations are used for one thing only: when a variable is used to "enumerate" different, mutually-exclusive possibilities. For general named constants use #define.

Recursion

God is subtle but he is not malicious.
Einstein

Functions that call themselves

void myfun(some_args) {

 /* Do some stuff */
  if ( some_test)
     myfun(some_other_args);
}

A variation on the above is to do the test inside the function:

void myfun(some_args) {
  if (I_didnt_need_to_be_called)
    return;

 /* Do some stuff */
    myfun(some_other_args);
}

Where it works this is neater (as we do the test only once).

When functions call themselves each instance has its own local variables, unless they are static.

Example: flood fill

A common siuation, with a number of variations, is when we have a rectangular grid of integer values, typically representing an image, and we wish to identify "islands", i.e. sets of neighbouring pixels with the same value.

In the following example we wish to identify and number "islands" in an empty "sea".

The initial description

#include<stdio.h>

/*
 * Demonstrate a flood fill, using it to count and label non-empty
 * contiguous regions in an image.  
 *
 * An image point that is empty has the value
 * zero, if it is non-empty but not yet assigned to a region
 * it has the value minus one. Pixels that have been assigned
 * to regions have the values one, two, three, etc. according
 * to the region they belong to.
 */

#define NX 10000
#define NY 10000
 

The flood fill function

/*
 * Simple flood filler: set all contiguous spaces with value "-1"
 * to the value "area_id".
 */
void floodfill(int image[NX][NY], int x, int y, int area_id) {
  int ix, iy;

  if (x < 0 || x >= NX || y < 0 || y >= NY || image[x][y] != -1)
    return;

  image[x][y] = area_id;

  for (ix = x-1; ix <= x+1; ++ix)
    for (iy = y-1; iy <= y+1; ++iy)
      floodfill(image, ix, iy, area_id);
} 

Notes

1. The first thing we do is to see if the function needs to do anything, if not we immediately return.
2. We check the co-ordinates are in range before checking the pixel (image) value at that point.
3. Then the first thing we do is to mark the pixel as filled.
4. Then we try each of its neighbours. (We also try the original point but that doesn't matter as it immediately returns.)

Had we reversed the last two steps then the function would have been forever calling itself. It would have done this even if we had put in an if() statement to avoid refilling itself:

  for (ix = x-1; ix <= x+1; ++ix)
    for (iy = y-1; iy <= y+1; ++iy)
      if ( ix != x || iy != y)
        floodfill(image, ix, iy, area_id);

  image[x][y] = area_id;  // Too late!!

The outer function

All we need to do now is to go over each point in the image and call ,tt.floodfil() for each point that needs it:

/* 
 * Count and label contiguous areas in an image.
 * On input: 0 means empty space, -1 means non-empty
 *
 * On exit the contiguous areas have the values 1, 2, 3 etc
 * and the number of areas is returned.
 */
int count_and_label(int image[NX][NY]) {
  int x, y, area_id = 0;

  for (x = 0; x < NX; ++x)
    for (y = 0; y < NY; ++y)
      if (image[x][y] == -1)
	floodfill(image, x, y, ++area_id);
    
  return area_id;
} 

This will fill the first island/region with the value "1", the second with the value "2", etc. and return the total number of regions found.

When recursion goes wrong

Consider the following rather over-the-top way of calculating a factorial:

int factorial(int i) {

  if ( 1 > 0 ) // Bug!
    return  i * factorial(i - 1);
  return 1;
}

int factorial(int i) {

  fprintf(stderr, "i: %d\n", i);
  if ( 1 > 0 ) // Bug!
    return  i * factorial(i - 1);
  return 1;
}

int factorial(int i, int depth) {
  int d;

  for(d = 0; d <= depth; ++d)
    fprintf(stderr, "  ");
  fprintf(stderr, "i: %d (depth %d)\n", i, depth);
  if ( depth > 12) {
    fprintf(stderr, "Too deep!\n");
    abort();
  }

  if ( 1 > 0 ) // Bug!
    return  i * factorial(i - 1);
  return 1;
}

• We have added an extra 'depth' argument which we increment by one every time.

• We have indented the output according to the depth. This isn't necessary but it is nice.
• Finally, and rather extremely, we have called abort() if factorial() goes too deep. This is only useful when we are running under the debugger as we can look at the "layers" of recursive call.

Be prepared to add some debugging output to your recursive routine.

Using a wrapper

int factorial(int i) {
  return  factorial_debug(i, 0);
}

Bitwise operators

Bitwise operators operate on the individual bits of a variable, rather than the arithmetis value of the whole variable as the arithmetic operators do.

The operators

NB the One's complement operator takes a single argument, the others two.

Examples

Binary flags

#define OPTION1 0x01  /*  1 binary 00000001 */
#define OPTION2 0x02  /*  2 binary 00000010 */
#define OPTION3 0x04  /*  4 binary 00000100 */
#define OPTION4 0x08  /*  8 binary 00001000 */
#define OPTION5 0x10  /* 16 binary 00010000 */
#define OPTION6 0x20  /* 32 binary 00100000 */

unsigned int flags;
 
int main(void) {
 
  flags |= OPTION3; /* Set OPTION3 */
  flags &= ~OPTION4; /* Unset OPTION4 */
  
  if ( flags & OPTION3)
    printf("Option 3 is set\n");
   
}

• The bit that was one in OPTION4 is zero ~OPTION4 so the binary and for that bit must always be zero.

• The bit that was zero in OPTION4 is one ~OPTION4 so the binary and for that bit will be one if and only if the corresponding bit in flags was one. That is to say, it is not changed.

00111011
11110111
--------
00110011

Pseudo-random numbers

The function rand() produces a pseudo-random number, for example:

int diceroll;

diceroll = 1 + (rand() % 6);

By default it always produces the same pseudo-random sequence each time the program is run. The traditional way round this is:

#include<time.h>
#include<stdlib.h>

int main() {
  int i;

  srand(time(NULL)); // Call this just once per program!

  for(i = 0; i < 20; ++i)
    printf("You have rolled %d\n",  1 + (rand() % 6));

  return 0;