Aggregate Data Types

struct and typedef

struct tag {
	type1	field1;
	type2	field2;
	...
	typen	fieldn;
} varname1, varname2, ..., varnamem;

struct student {
	int	id;
	char	classification;
	float	gpa;
} bob;

struct student alice;

	bob.gpa = 4.0; 		/* good student */
	bob.id = 1234567;
	bob.classification = 'f';

	alice = bob;

C had been evolving for some time when a new keyword was added: typedef. This keyword allows the programmer to make up new type names that work just like the basic type names in variable declarations. A typedef statement looks just like a variable declaration, except that its preceded with the word typedef. For example:

typedef int MyInt;

MyInt	a, b, c;

typedef struct student {
	int	id;
	char	classification;
	float	gpa;
} student_t;

student_t	alice, bob;

student_t	students[1000];

	int	i;

	for (i=0; i<1000; i++) {
		students[i].id = something;
		students[i].classification = something else;
		etc...
	}
}

Pointers

Bytes in the computer can be organized into groups so that they can function as different types of variables; for example, integers (4 bytes on the Sun), doubles (8 bytes on the Sun), and other basic types, as well as aggregates (e.g. arrays and structs in C) of basic types.

Before a program begins to run, the operating system allocates a certain area of the computer's memory to hold the program and all of its variables. As long as your program refers to values stored in memory in this area, everything runs OK. When your program tries to access memory outside its area (for example, by indexing an array out of bounds), the system will complain bitterly, usually causing your program to stop running. This is to protect other programs from unauthorized (and probably accidental) access from your program.

A pointer is the programming language representation of the memory address of a variable. A pointer holds information about the location of a variable, not its value. The variable can be modified through the pointer.

A pointer must point to something valid, i.e., a memory location allocated to your program, before the value it points to is accessed. If not, the system will complain.

You can declare variables to be pointers. Pointer variables are declared to point to a certain type. Once the pointer contains a valid memory address, you can modify or read the contents of the that memory (and sometimes adjacent memory) in a variety of ways.

Pointers in C

int main () {
	float	a;	/* a is a float variable */
	float	*p;	/* p is a pointer to float */

	/* p is uninitialized.  let's give it the address of a */

	p = &a;

	/* now *p is an "alias," or another name for, a.  let's modify a. */

	*p = 23;

	/* let's print out the value of a */

	printf ("%f\n", a);

	/* the output should be 23, even though we never explicitly
	 * changed a
	 */
	exit (0);
}

Pointers (in)to Arrays

	int	v[100], *p;

	p = &v[0];	/* now p is an alias for v */
	p[5] = 123;	/* v[5] is now 123 */

	int	v[100], *p;

	p = &v[20];	/* p points to memory starting at v[20] */
	p[5] = 123;	/* v[25] is now 123 */

Pointer Arithmetic

	int	v[100], *p, i;

	p = &v[20];

	/* let i go from 0 through 19 */

	for (i=0; i<20; i++) {
		*p = 0;	/* what p points to is assigned zero */
		p++;	/* increment p so that it points to the 
			   next integer in the array */
	}

Pointers to Structures

typedef struct _foo {
	int	a;
	double	b;
	char	c;
} foo;

int main () {
	foo	bar, 	/* 'bar' is of structure type 'foo' */
		*q;	/* 'q' is of type pointer to 'foo' */

	q = &bar;
	(*q).a = 1;
	(*q).b = 3.14159;
	(*q).c = 'h';
	...
}

	q = &bar;
	q->a = 1;
	q->b = 3.14159;
	q->c = 'h';

The NULL Pointer

Dynamic Allocation

Suppose, for example, that we want to allow the user to specify how many items should be in an array of floats (because the user might be entering them by hand or from a file later). We can do this:

	int	n;
	float	v[100];

	printf ("How many? ");
	scanf ("%i", &n);
	if (n > 100) {
		printf ("too bad.\n");
	} else ...

malloc accepts an integer parameter and returns a pointer to that many newly allocated bytes (or NULL if the system failed to allocate enough memory). The pointer returned is either of type void * or char * depending on the compiler and/or operating system, so it usually isn't the type of pointer we want. So we must cast it to the type we want before we use it. We must also know how many bytes to allocate, so we have to find out the size, in bytes, of the data type we're allocating and multiply that by the number of items we want.

Here is how the above example would work with malloc:

#include <stdlib.h>	/* this is where malloc hangs out */
...
	int	n;
	float	*v;

	printf ("How many? ");
	scanf ("%i", &n);
	v = (float *) malloc (n * sizeof (float));
	if (!v) {
		printf ("unable to allocate enough memory, sorry!\n");
		exit (1);
	}
...

When we are done with memory that has been malloc'ed, we can return it to the system by calling free with the pointer allocated:

	float	*v;

	v = (float *) malloc (whatever...);
	...
	free (v);	/* return memory at v to the system */

Dynamic allocation allows us to define all kinds of abstract data types that can grow dynamically, bound only by the constraints of the operating system.

Example of Dynamic Allocation: Linked Lists

• create(L) - create an empty list.
• insert(L, k) - insert a value k into the list.
• search(L, k) - search for k in the list, returning a pointer to it if it is found, NULL otherwise.
• delete(L, k) - delete the first list item containing the value k.
• length(L) - return the number of items in the list.
• destroy(L) - get rid of a list, freeing up any storage allocated.

You can imagine how to implement this with an array, with all the limitations that implies. Another way is to use a linked list, a set of structs set up so that the first one in the next points to the second one, the second one points to the third, and so forth. The last struct in the list will contain a NULL pointer, to signal the end.

Here is a typedef/struct declaration for a single item in the list. structs like this are called list nodes, or simply nodes:

typedef struct _node {
	int		k;
	struct _node	*next;
} node;

So a linked list can be seen as a pointer to the first node (or to NULL), if the list is empty. Here is a typedef for our list ADT:

typedef node *list;

/* interface section for list ADT */

/* create an empty list (list is passed by reference) */
void create_list (list *);

/* insert an int into a list (list is passed by reference */
void insert_list (list *, int);

/* search a list for an int, returning a pointer to that int or NULL if
 * it isn't found 
 */
int *search_list (int);

/* delete the first list node containing this integer 
 * (list passed by reference)
 */
void delete_list (list *, int);

/* return the length of a list */
int length_list (list);

/* deallocate storage for a list (list passed by reference) */
void destroy_list (list *);

• create_list - just sticks a NULL pointer into the list node pointer.

  /* make an empty list by assigning it the NULL pointer. */
  void create_list (list *L) {
  	/* note that L is a pointer to a pointer! */
  
  	*L = NULL;
  }
  

• insert_list - allocate a new node and put it at the beginning of the list by making it the head of the list:

  void insert_list (list *L, int k) {
  	node	*p;
  
  	p = (node *) malloc (sizeof (node));
  	p->k = k;
  	p->next = *L;
  	*L = p;
  }
  

  For example, suppose we have a list like this:

            ___    ___    ___
     L ->  |_4_|->|_3_|->|_8_|->NULL
  
  

  and we want to insert the value 5 into the list. First we get a new node from malloc and put a pointer to it in p, assigning 5 to the k field:

                          ___
                    p -> |_5_|
            ___    ___    ___
     L ->  |_4_|->|_3_|->|_8_|->NULL
  
  

  Then we have the next field point to the rest of the list:

                      ___
                p -> |_5_|
                       |
                       v
                      ___    ___    ___
               L ->  |_4_|->|_3_|->|_8_|->NULL
  
  

  Then finally tell L that the new node is the beginning of the list:

                      ___
                L -> |_5_| <- p
                       |
                       v
                      ___    ___    ___
                     |_4_|->|_3_|->|_8_|->NULL
  

  Note that this works even when the original list is empty (i.e., *L is NULL).

  We'll figure out some of the rest of the operations in the lab, as well as possibly alternate ways of doing insert_list.