Module 3: Intermediate C

Let's look at an example that covers all the basic ideas: (source file)

// Define an enum type and give it the name skyColorType:
typedef enum skyColor {blue, orange, gray} skyColorType;

// Define a structure containing a double and a string. Note the
// use of typedef to name the structure.
typedef struct {
  double temperature;
  char *message;
} forecastInfo;

// Define a pointer type to the above structure.
typedef forecastInfo *forecastInfoPtrType;


// The function forecast returns a structure.

forecastInfo forecast (skyColorType c)
{
  // Declare a pointer to the struct.
  forecastInfoPtrType fInfoPtr;

  // Make the pointer point to a block of memory for the struct.
  fInfoPtr = (forecastInfoPtrType) malloc (sizeof (forecastInfo) * 1);

  if (c == blue) {
    fInfoPtr->message = "Sunny and warm!";    // Note the use of the "->" operator
    fInfoPtr->temperature = 85.5;             // because fInfoPtr is a pointer.
  }
  else if (c == orange) {
    fInfoPtr->message = "Enjoy the sunset";
    fInfoPtr->temperature = 77.3;
  }
  else if (c == gray) {
    fInfoPtr->message = "Stay inside";
    fInfoPtr->temperature = 64.7;
  }

  return *fInfoPtr;                           // Return the struct itself, not the pointer.
}


int main ()
{
  // Example of struct variable declaration:
  forecastInfo fInfo;

  fInfo = forecast (blue);

  // Note the use of the "." operator to access struct members.
  printf ("Temperature = %lf: %s\n", fInfo.temperature, fInfo.message);
}

• We have combined a struct definition with typedef because it makes the code appear cleaner.

• A struct can be defined without a typedef. Here's the same example without typedef: (source file)

  enum skyColor {blue, orange, gray};    // Foregoes the use of typedef.
  
  struct forecastStruct {                // Now the struct has a name. 
    double temperature;
    char *message;
  };
  
  
  // Return type needs both the "struct" keyword and the struct name.
  // Parameter needs both the "enum" keyword and the enum name.
  
  struct forecastStruct forecast (enum skyColor c)      
  {
    // Pointer declaration without typedef.
    struct forecastStruct *fInfoPtr;
  
    // Note the full type specification for sizeof and the cast.
    fInfoPtr = (struct forecastStruct *) malloc (sizeof (struct forecastStruct) * 1);
  
    // ...
  }
  
  
  int main ()
  {
    // Example of struct variable declaration:
    struct forecastStruct fInfo;
  
    fInfo = forecast (blue);
  
    // ...
  }
      

• Because we used a typedef we did not need to name the struct, although that would cause no harm:

  typedef struct whatever {
    double temperature;
    char *message;
  } forecastInfo;
      

• Recall that malloc takes the required space (in bytes) as argument. Since we don't know how many bytes are needed, we use the sizeof operator:

    fInfoPtr = (forecastInfoPtrType) malloc (sizeof (forecastInfo) * 1);
      

  where the struct name is passed to sizeof.

• Similarly the pointer returned by malloc points to a block of bytes, and must be cast into the appropriate pointer type, in this case: a pointer to the struct type.

• Given a pointer-to-struct variable like fInfoPtr, an individual member field is accessed using the -> operator:

      fInfoPtr->temperature = 77.3;
      

• On the other hand, a struct variable like fInfo must use the . operator:

    printf ("Temperature = %lf: %s\n", fInfo.temperature, fInfo.message);
      

Linked lists

Let's look at an example: (source file)

// From the previous example:
typedef enum skyColor {blue, orange, gray} skyColorType;

typedef struct {
  double temperature;
  char *message;
  char *city;
} forecastInfo;


// Structure of each list node:
typedef struct ListNode {
  forecastInfo fInfo;
  struct ListNode *next;
} ListNodeType;

// A list node pointer type:
typedef ListNodeType *ListNodePtrType;


// The list's front and rear pointers:
ListNodePtrType front = NULL, rear = NULL;


// Add a new node to the rear of the list.

void add (char *city, double temp, char *message)
{
  // Allocate space for the node:
  ListNodePtrType listPtr = (ListNodePtrType) malloc (sizeof (ListNodeType));

  // Fill data.
  listPtr->fInfo.city = city;
  listPtr->fInfo.temperature = temp;
  listPtr->fInfo.message = message;
  listPtr->next = NULL;

  if (front == NULL) {
    // If list is empty, front and rear point to same node.
    front = rear = listPtr;
    return;
  }

  // Otherwise, we know there's at least one element, so
  // add the new node past the current rear node.
  rear->next = listPtr;
  rear = rear->next;
}


void printList ()
{
  ListNodePtrType listPtr;

  printf ("List :\n");

  // Start at the front and walk through the list.
  listPtr = front;
  while (listPtr != NULL) {
    // Process current node.
    printf ("  Forecast for %s: temperature=%lf  %s\n", listPtr->fInfo.city, 
            listPtr->fInfo.temperature, listPtr->fInfo.message);

    // Move on to next node.
    listPtr = listPtr->next;
  }
}



int main ()
{
  add ("DC", 85.6, "Hot");
  printList ();
  add ("LA", 72.6, "Warm");
  printList ();
  add ("NY", 64.6, "Cool");
  printList ();
}