CS 2213 Advanced Programming
Structures

Introduction

6.1 Basics of Structures

Here is how we would make a point structure in C:

   struct point {
      int x;
      int y;
   };

The variables named in the structure are called its members.
These names only have to be unique with the structure.
The same names can be used outside the structure to represent different variables.
The structure tag may also be the same as the name of a variable, but this should be avoided.

The struct definition defines a new type and variables can be declared with that type once the structure is declared.

struct point pt1, pt2, pt3;

You can initialize variables by listing the values of the members in braces:

struct point pt1 = {100,200};

You can reference the members of a structure with the same notations as you use for fields of a class:

struct point pt1, pt2, pt3;

pt1.x = 4;
pt1.y = 5;
printf("The point has x value %d and y value %d\n",pt1.x,pt1.y);

struct line {
   struct point pt1;
   struct point pt2;
};
struct line myline;
myline.pt1.x = 3;
myline.pt1.y = 4;
myline.pt2.x = 5;
myline.pt2.y = 7;
printf("My line starts at (%d,%d) and ends at (%d,%d)\n",
       myline.pt1.x,myline.pt1.y,myline.pt2.x,myline.pt2.y);

6.2 Structures and Functions

#include <stdio.h>
 
struct point {
   int x;
   int y;
};

struct line {
   struct point pt1;
   struct point pt2;
};
 
void showpoint(char *msg, struct point apoint) {
 
   printf("%s is at (%d,%d)\n",msg,apoint.x,apoint.y);
 
}
 
void showline(char *msg, struct line aline) {
 
   printf("%s starts at (%d,%d) and ends at (%d,%d)\n\n",msg,
           aline.pt1.x, aline.pt1.y, aline.pt2.x, aline.pt2.y);
 
}
 
void changepoint(struct point apoint) {
 
   showpoint("In change point before change point is ",apoint);
   apoint.x++;
   showpoint("In change point after  change point is ",apoint);
 
}
 
struct point addpoints(struct point point1, struct point point2) {
 
   point1.x = point1.x + point2.x;
   point1.y = point1.y + point2.y;
 
   return point1;
 
}
 
int main() {
 
   struct line myline;
 
   struct point firstpoint = {4, 12};
   struct point secondpoint;
 
   secondpoint = firstpoint;
   secondpoint.x++;
   secondpoint.y--;
 
   myline.pt1 = firstpoint;
   myline.pt2 = secondpoint;
 
   showpoint("firstpoint",firstpoint);
   showpoint("secondpoint",secondpoint);
   showline("My line ",myline);
 
   firstpoint.x = 17;
   showpoint("firstpoint",firstpoint);
   showpoint("secondpoint",secondpoint);
   showline("My line ",myline);
 
   changepoint(firstpoint);
   showpoint("After changepoint returns,    point is ",firstpoint);
 
   printf("\n");
   showpoint("Before addpoints,  firstpoint",firstpoint);
   showpoint("Before addpoints, secondpoint",secondpoint);
   secondpoint = addpoints(firstpoint,secondpoint);
   showpoint("After  addpoints,  firstpoint",firstpoint);
   showpoint("After  addpoints, secondpoint",secondpoint);
 
   return 0;
 
}

firstpoint is at (4,12)
secondpoint is at (5,11)
My line  starts at (4,12) and ends at (5,11)

firstpoint is at (17,12)
secondpoint is at (5,11)
My line  starts at (4,12) and ends at (5,11)

In change point before change point is  is at (17,12)
In change point after  change point is  is at (18,12)
After changepoint returns,    point is  is at (17,12)

Before addpoints,  firstpoint is at (17,12)
Before addpoints, secondpoint is at (5,11)
After  addpoints,  firstpoint is at (17,12)
After  addpoints, secondpoint is at (22,23)

Note that in C, function parameters are always passed by value.

Why does it work to pass an array to a function that changes the array, but it does not work to pass and int or struct point to a function to change its value?

Differences between Java and C

Java Code:                  C Code:

P1 = new Point(1,2);        struct point p1 = {1,2};
P2 = new Point(3,4);        struct point p2 = {3,4};
P2 = P1;                    p2 = p1;
P1.x = 17;                  p1.x = 17;

We can simulate the new Point of Java with the following:

struct point makepoint(int x, int y) {
   struct point temp;
   temp.x = x;
   temp.y = y;
   return temp;
}

How do you pass a structure to a function so that it can be modified?
You do this the same way as you would with an int.
You pass a pointer to it.

struct point *mypointp;

struct point *mypointp;
struct point p;
mypointp = &p;
(*mypointp).x = 17;

Because this combination occurs so often, there is an operator to handle this directly:
mypointp -> x is the same as (*mypointp).x, so we can write:

mypointp->x = 17;

#include <stdio.h>

struct point {
   int x;
   int y;
};

void showpoint(char *msg, struct point apoint) {

   printf("%s is at (%d,%d)\n",msg,apoint.x,apoint.y);

}

void changepointok(struct point *apointp) {

   showpoint("In change point before change point is ",*apointp);
   apointp -> x++;
   showpoint("In change point after  change point is ",*apointp);

}

int main() {

   struct point firstpoint = {4, 12};

   changepointok(&firstpoint);
   showpoint("After changepoint returns,    point is ",firstpoint);

   return 0;

}

In change point before change point is  is at (4,12)
In change point after  change point is  is at (5,12)
After changepoint returns,    point is  is at (5,12)

What is wrong with the following?:

struct point *mypointp;
struct point p;
*mypointp = p;
(*mypointp).x = 17;

Consider the following:

struct stringwithlength {
   int len;
   char *str;
} *p;

The sizeof operator can tell you the size of a variable or a type.
You can use either:
sizeof object
or
sizeof(typename)

For example, on our system
sizeof(int)
will return 4 and
sizeof(int *)
will also return 4.

What about sizeof(stringwithlength)?

This is an error, but
What about sizeof(struct stringwithlength)?

This gives 8.

Suppose we had

struct newstringwithlength { 
   int len; 
   char str[10]; 
}; 

16    Why is that?

consider

   struct newstringwithlength x;
   printf("x.len has size %d\n",sizeof(x.len));
   printf("x.str has size %d\n",sizeof(x.str));
   printf("x has size %d\n",sizeof(x));

x.len has size 4
x.str has size 10
x has size 16

Results may be different on different hardware, even when ints are 4 bytes.

6.7 Typedef

The library routine strlen has the prototype:

      size_t strlen(const char *s);

typedef unsigned int    size_t;

Typedefs are often used with structures. For example

typedef struct stringval {
   char *str;
   int val;
} strval;

   strval sval;

One usual way of doing this is to use the same name for the new type as the structure name:

typedef struct stringval { 
   char *str; 
   int val; 
} stringval; 

   struct stringval sval;
   stringval sval;

typedef struct { 
   char *str; 
   int val; 
} stringval; 

   stringval sval;

What is the difference between the following:

typedef struct {              struct {
   char *str;                    char *str;
   int val;                      int val;
} stringval;                  } stringval;

The one on the left defines stringval as a new type.
The one on the right defines a variable, stringval, which can contain a structure.

6.3 Arrays of Structures

typedef struct {
   char *str;
   int val;
} stringval;

#define NUMSTRINGS 1000
stringval mystrings[NUMSTRINGS];

int binsearch(char *str, stringval *sval, int size);

int binsearch(char *str, stringval mystrings[], int size) {
   int cond;
   int low;
   int high;
   int mid;

   low = 0;
   high = size - 1;
   while (low <= high) {
      mid = (low + high)/2;
      cond = strcmp(str,mystrings[mid].str);
      if (cond < 0)
         high = mid - 1;
      else if (cond > 0)
         low = mid + 1;
      else
         return mid;
    }
    return -1;
}

6.4 Pointers to Structures

stringval *binsearch(char *str, stringval *mystrings, int size);

stringval *binsearch(char *str, stringval *mystrings, int size) {
   int cond;
   stringval *low;
   stringval *high;
   stringval *mid;

   low = mystrings;
   high = &mystrings[size-1];
   while (low <= high) {
      mid = low + (high-low)/2;
      cond = strcmp(str,mid->str);
      if (cond < 0)
         high = mid - 1;
      else if (cond > 0)
         low = mid + 1;
      else
         return mid;
   }
   return NULL;
}

The problem is that we are not allowed to dereference pointers outside the array, and in fact, we should not even be allowed to computer a pointer to something outside of the array.

Suppose that the array has 2 elements starting at location 1000 and that sizeof(stringval) is 8.

Suppose also that the string we are looking for is not in the array and in fact is smaller than any of the stored strings.

We start with (addresses in bold):
low = 1000
high = 1008
mid = 1000 + (1008 - 1000)/2 = 1000 + 1/2 = 1000 + 0 = 1000;
cond < 0 so
high = 1000 - 1 = 992;
But we are not even allowed to make such a pointer this way.

We can solve the problem by reorganizing the code slightly.
The C standard allows us to compute (but not dereference) the pointer just past the end of an array.

In the following, the string we are looking for is between mystrings[low] and mystrings[high], including the left endpoint, but not including the right endpoint.

 
stringval *binsearch(char *str, stringval *mystrings, int size) {
   int cond; 
   stringval *low; 
   stringval *high; 
   stringval *mid; 
 
   low = mystrings; 
   high = &mystrings[size]; 
   while (low < high) { 
      mid = low + (high-low)/2; 
      cond = strcmp(str,mid->str); 
      if (cond < 0)
         high = mid;
      else if (cond > 0)
         low = mid + 1;
      else
         return mid;
   }
   return NULL;
}

6.5 Self-referential Structures

We have already looked at an array implementation of a stack.

This has the limitation of a fixed maximum size.

We will consider a stack of stringval items.
Each stack element will contain a stringval and a pointer to the next element on the stack.

struct stackentry {
   stringval sval;
   struct stackentry *next;
};

typedef struct stackentry {
   stringval sval;
   struct stackentry *next;
} stackentry;

Notice that the following is not allowed:

typedef struct stackentry {
   stringval sval;
   stackentry *next;
} stackentry;

We will make a "stack object" which will use a linked list to implement the stack.
Here is the contents of the stack.h file:

typedef struct stringval {
   char *str;
   int val;
} stringval;

int push(stringval sval);
stringval *pop(void);
void printstack(void);

The push returns true on success and false on failure.
The pop removes the item from the top of the stack and returns a pointer to it.
It returns NULL if the stack was empty.

There are many ways to represent a stack using linked lists.
In our implementation, an entry on the stack will contain a stringval and a pointer to the next element on the stack.

The stack itself will just be a pointer to a stack entry.
The pointer will be NULL when the stack is empty.

Here is what the stack.c file might look like:

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

typedef struct stackentry {
   stringval sval;
   struct stackentry *next;
} stackentry;

typedef stackentry *stack;

static stack mystack = NULL;

static stackentry *make_entry(stringval sval) {
   ...
}

/* return true if success, false if error */
int push(stringval sval) {
   ...
}

/* remove and return pointer to top item if OK, NULL if error */
stringval *pop() {
   stringval *svalp;
   ...
   return svalp;
}

void printstack() {
   stackentry *this;
   int count = 0;
   this = mystack;
   printf("Stack follows:\n");
   while (this != NULL) {
      printf("%10d %s\n",this->sval.val,this->sval.str);
      this = this->next;
      count++;
   }
   printf("Number of entries found: %d\n",count);
}

Here is a main program that can be used to test the stack:

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

static void testpush(char *str, int val) {
   stringval sval;
   sval.val = val;
   sval.str = str;
   printf("Before push\n");
   printstack();
   if (push(sval) < 0)
      printf("push failed\n");
   printf("After push of %s\n",str);
   printstack();
   printf("\n");
}

static void testpop() {
   stringval *svalp;
   printf("Before pop\n");
   printstack();
   svalp = pop();
   if (svalp == NULL)
      printf("pop failed\n");
   else
     printf("poped: %10d %s\n",svalp->val,svalp->str);
   printf("After pop\n");
   printstack();
   printf("\n");
}

int main() {
   testpop();
   testpush("this is pushed first",10);
   testpush("this is pushed second",20);
   testpop();
   testpop();
   testpop();
   testpush("this is pushed first again",30);
   testpush("this is pushed second again",40);
   testpop();
   return 0;
}

Before pop
Stack follows:
Number of entries found: 0
pop failed
After pop
Stack follows:
Number of entries found: 0

Before push
Stack follows:
Number of entries found: 0
After push of this is pushed first
Stack follows:
        10 this is pushed first
Number of entries found: 1

Before push
Stack follows:
        10 this is pushed first
Number of entries found: 1
After push of this is pushed second
Stack follows:
        10 this is pushed first
        20 this is pushed second
Number of entries found: 2

Before pop
Stack follows:
        10 this is pushed first
        20 this is pushed second
Number of entries found: 2
poped:         10 this is pushed first
After pop
Stack follows:
        20 this is pushed second
Number of entries found: 1

Before pop
Stack follows:
        20 this is pushed second
Number of entries found: 1
poped:         20 this is pushed second
After pop
Stack follows:
Number of entries found: 0

Before pop
Stack follows:
Number of entries found: 0
pop failed
After pop
Stack follows:
Number of entries found: 0

Before push
Stack follows:
Number of entries found: 0
After push of this is pushed first again
Stack follows:
        30 this is pushed first again
Number of entries found: 1

Before push
Stack follows:
        30 this is pushed first again
Number of entries found: 1
After push of this is pushed second again
Stack follows:
        30 this is pushed first again
        40 this is pushed second again
Number of entries found: 2

Before pop
Stack follows:
        30 this is pushed first again
        40 this is pushed second again
Number of entries found: 2
poped:         30 this is pushed first again
After pop
Stack follows:
        40 this is pushed second again
Number of entries found: 1

• After the first two pushes, the lines are in the wrong order
• This means that either the push or the print is wrong.
• After the first pop we see that the wrong value was popped.
• This indicates that the push was probably wrong.

Before pop
Stack follows:
Number of entries found: 0
pop failed
After pop
Stack follows:
Number of entries found: 0

Before push
Stack follows:
Number of entries found: 0
After push of this is pushed first
Stack follows:
        10 this is pushed first
Number of entries found: 1

Before push
Stack follows:
        10 this is pushed first
Number of entries found: 1
After push of this is pushed second
Stack follows:
        20 this is pushed second
        10 this is pushed first
Number of entries found: 2

Before pop
Stack follows:
        20 this is pushed second
        10 this is pushed first
Number of entries found: 2
poped:         20 this is pushed second
After pop
Stack follows:
        10 this is pushed first
Number of entries found: 1

Before pop
Stack follows:
        10 this is pushed first
Number of entries found: 1
poped:         10 this is pushed first
After pop
Stack follows:
Number of entries found: 0

Before pop
Stack follows:
Number of entries found: 0
pop failed
After pop
Stack follows:
Number of entries found: 0

Before push
Stack follows:
Number of entries found: 0
After push of this is pushed first again
Stack follows:
        30 this is pushed first again
Number of entries found: 1

Before push
Stack follows:
        30 this is pushed first again
Number of entries found: 1
After push of this is pushed second again
Stack follows:
        40 this is pushed second again
        30 this is pushed first again
Number of entries found: 2

Before pop
Stack follows:
        40 this is pushed second again
        30 this is pushed first again
Number of entries found: 2
poped:         40 this is pushed second again
After pop
Stack follows:
        30 this is pushed first again
Number of entries found: 1

Time to write int push(stringval sval) and stringval *pop() as well as static stackentry *make_entry(stringval sval)

Here is the code we wrote in class on Tuesday:

static stackentry *make_entry(stringval sval) {
   stackentry *entryp;
   entryp =(stackentry *)malloc(sizeof(stackentry));
   if(entryp==NULL)
      return NULL;
   entryp->sval =sval;
   entryp->next =NULL;
   return entryp;
}

int push(stringval sval){
    stackentry *entryp;
    
    entryp = make_entry(sval);
    if(entryp == NULL)
       return 0;
    entryp-->next = mystack;
    mystack = entryp;
    return 1;
}

stringval *pop(){
   stringval *sval;
   if(mystack == NULL)
     return NULL;
   ...

An alternative is to define another stack function:

int stackempty(void);

stringval pop(void);

Here is what we wrote in class:

stringval *pop() { 
    stringval *svalp; 
    if (mystack == NULL) 
        return NULL;   
    svalp = &mystack -> next;
    return svalp;
} 

An alternative is to return a stringval directly, but have another function to test the stack for empty. We looked at these two implementations:

int stackempty() {
    if(mystack == NULL)
        return 1;
    else
        return O;
}    
 
int stackempty() {
    return (mystack == NULL);
}

stringval pop() {
    stringval sval;
    stackentry *entryp;
    sval = mystack -> sval;
    entryp = mystack;
    mystack = mystack -> next;
    free (entryp);
    return sval;
}

Before returning to queues, here is some information about Programming Assignment 3.

And here is some information about the exam next week.

A queue implementation

You might want to review the notes on stacks which have been updated to reflect what we did on class.

Review: with a few changes for clarification, e.g. back to prev.

An example of a doubly linked list.

In a queue, items are inserted at one end and taken out of the other.

A node entry might look like this:

typedef struct nodeentry {
   stringval sval;
   struct nodeentry *next;
   struct nodeentry *prev;
} nodeentry;

The queue itself will need a pointer to the start and a pointer to the end:

typedef struct {
   nodeentry *front;
   nodeentry *rear;
} queue;

The two main operations are insert and remove:

/* insert a node at the end of the list */
int qinsert(stringval sval);

/* remove a node from the front of the list */
stringval qremove(void);

int qempty(void);

When writing the queue routines, you should think about the testing process.
One of the problems with a doubly linked list is that it can become inconsistent.
You might want to write a routine to check that the queue is valid:

int qcheck();

Think about what you need to verify for a doubly linked list to be consistent.

static queue q = {NULL,NULL};

/* Return true if OK, false if bad */
int qcheck() {
   nodeentry *ne;
   int count;
   if ( (q.front == NULL) && (q.rear != NULL) ) {
      printf("front is NULL but rear is not\n");
      return 0;
   }
   else if ( (q.rear == NULL) && (q.front != NULL) ) {
      printf("rear is NULL but front is not\n");
      return 0;
   }
   else if (q.front == NULL) return 1;
   if (q.front->next != NULL) {
      printf("First node does not point forward to NULL\n");
      return 0;
   }
   if (q.rear->prev != NULL) {
      printf("Last node does not point back to NULL\n");
      return 0;
   }
   ne = q.rear;
   count = 0;
   while (ne->next != NULL) {
      if (ne->next->prev != ne) {
         printf("Node %d points to node which does not point back to it\n",
                count);
         return 0;
      }  
      ne = ne->next;
   }
   if (ne != q.front) {
      printf("Last node doing forward links is not pointed to by front\n");
      return 0;
   }
   return 1;
}

void showqueue() {
   int count;
   nodeentry *ne;

   if (q.front == NULL) {
      printf("Queue is empty\n");
      return;
   }
   count = 0;
   ne = q.front;
   while (ne != NULL) {
      count++;
      ne = ne->prev;
   }
   printf("Number of entries in queue: %d\n",count);
   ne = q.front;
   count = 1;
   while (ne != NULL) {
      printf("%5d: %5d %s\n",count,ne->sval.val,ne->sval.str);
      ne = ne->prev;
      count++;
   }
}

Here is a program for testing the queue:

#include <stdio.h>
#include "queue.h"

static void checkit() {
   if (qcheck())
      printf("Queue is OK\n");
}

static void testremove() {
   stringval sval;
   printf("Before remove queue is\n");
   showqueue();
   printf("After remove\n");
   if (qempty()) 
      printf("Remove failed\n");
   else {
      sval = qremove();
      printf("Removed:  %5d %s\n",sval.val,sval.str);
   }
   showqueue();
   checkit();
   printf("\n");
}

static void testinsert(int val, char *str) {
   stringval sval;
   sval.val = val;
   sval.str = str;
   printf("Before insert queue is\n");
   showqueue();
   printf("After insert of %d %s\n",val,str);
   if (!qinsert(sval))
      printf("Insert failed\n");
   showqueue();
   checkit();
   printf("\n");
}
   
int main() {
   checkit();
   showqueue();
   printf("\n");

   testremove();
   testinsert(10,"This is a test");
   testinsert(20,"This is only a test");
   testinsert(30,"If this were a real queue, it would be used for something");
   testremove();
   testremove();
   testinsert(40,"OK, we are almost done");
   testremove();
   testremove();
   testremove();
   return 0;
}

Queue is OK
Queue is empty

Before remove queue is
Queue is empty
After remove
Remove failed
Queue is empty
Queue is OK

Before insert queue is
Queue is empty
After insert of 10 This is a test
Number of entries in queue: 1
    1:    10 This is a test
Queue is OK

Before insert queue is
Number of entries in queue: 1
    1:    10 This is a test
After insert of 20 This is only a test
Number of entries in queue: 2
    1:    10 This is a test
    2:    20 This is only a test
Queue is OK

Before insert queue is
Number of entries in queue: 2
    1:    10 This is a test
    2:    20 This is only a test
After insert of 30 If this were a real queue, it would be used for something
Number of entries in queue: 3
    1:    10 This is a test
    2:    20 This is only a test
    3:    30 If this were a real queue, it would be used for something
Queue is OK

Before remove queue is
Number of entries in queue: 3
    1:    10 This is a test
    2:    20 This is only a test
    3:    30 If this were a real queue, it would be used for something
After remove
Removed:     10 This is a test
Number of entries in queue: 2
    1:    20 This is only a test
    2:    30 If this were a real queue, it would be used for something
Queue is OK

Before remove queue is
Number of entries in queue: 2
    1:    20 This is only a test
    2:    30 If this were a real queue, it would be used for something
After remove
Removed:     20 This is only a test
Number of entries in queue: 1
    1:    30 If this were a real queue, it would be used for something
Queue is OK

Before insert queue is
Number of entries in queue: 1
    1:    30 If this were a real queue, it would be used for something
After insert of 40 OK, we are almost done
Number of entries in queue: 2
    1:    30 If this were a real queue, it would be used for something
    2:    40 OK, we are almost done
Queue is OK

Before remove queue is
Number of entries in queue: 2
    1:    30 If this were a real queue, it would be used for something
    2:    40 OK, we are almost done
After remove
Removed:     30 If this were a real queue, it would be used for something
Number of entries in queue: 1
    1:    40 OK, we are almost done
Queue is OK

Before remove queue is
Number of entries in queue: 1
    1:    40 OK, we are almost done
After remove
Removed:     40 OK, we are almost done
Queue is empty
Queue is OK

Before remove queue is
Queue is empty
After remove
Remove failed
Queue is empty
Queue is OK

Time to write int qempty(void),, int qinsert(stringval sval) and stringval qremove()

Here is what we did in class:

int qempty(void) {
    return q.front == NULL;
}

int qinsert(stringval sval) {
   nodeentry *entryp;
   nentryp = (nodeentry*)malloc(sizeof(nodeentry));
   if (nentryp == null)
       return 0;
   nentryp->sval = sval;
   nentryp->prev = NULL;
   nentryp->next = q.rear;
   q.rear = nentryp;
   if (q.front == NULL) 
       q.front = nentry;
   else
      q.rear->next->prev = nentryp;
   return 1;
}

/* This assumes the queue is not empty */
stringval qremove() {

}

stringval qremove() {
    stringval sval;
    sval = q.front -> sval;
    if (q.front -> prev == NULL) {
        free(q.front);
        q.front = NULL;
        q.rear = NULL;
        return sval;
    }
    q.front = q.front -> prev;
    free(q.front -> next);
    q.front -> next = NULL;
    return sval;
}

Here is information about the last programming assignment.

Here is some review material for the exam.

6.6 Table Lookup

6.8 Unions

Example:

union sigval {
   int   sival_int;
   void  *sigval_ptr;
}

Next Topic: Input and Output