Computer Programming (13) - User Defined data structures

administrivia

Web Page - http://www.cs.tau.ac.il/~efif/courses/ComputerProgramming

user-defined data structures

basic types - char, int, long int, double, etc.
derived types - arrays of basic types, pointers to basic types, and functions returning basic types.
another way to derive types - by building user-defined types
- collections of associated values can all have different types
  - an array - a collection of associated values, all of the same type

structures

K&R Sec. 6.1
basic user-defined data type in C is the structure, or struct
- analogous to the records found in some other languages
first you define a ``template''
- describes the new type
then, you declare variables having the new type (or functions returning the new type, etc.)

example

representing complex numbers
- a complex number consists of a "real" and "imaginary" part
- the imaginary part is some multiple of the square root of negative 1
  - no need to understand complex numbers to understand this example
FORTRAN has a built-in complex type, but C does not
need a way of holding both these quantities in one data type
struct complex { double real; double imag; };

structure parts

a structure declaration consists of up to 4 parts:
- the keyword struct - indicates a structure
- a name or tag by which this structure will be known
- a list of the structure's members enclosed in braces {}
  - also called components or fields
  - contains declarations of ordinary variables
- a list of variables defined with the struct being their data type

structure members

each member has a name and a type, just like ordinary variables
defining the collection of data types which will make up the structure
the complex structure is made up of two members
- both of type double
- one named real and one named imag

structure variable definition

complex is the name of the structure type
the names real and imag are are identifiers for the two components of the structure.
declare variables of complex type like these:
struct complex c2, c3;
just like previous declarations of variables having basic types
- instead of a type keyword like int, two-word type name struct complex

structure variable definition

the only memory allocated is for 2 values of type double
all the names are just for our convenience and the compiler's reference
structure do not quite define a new type on a par with int or double
- we can not say
  complex c1; /* WRONG */
- there is a way to define new full-fledged type names
- in C++ a new structure does automatically become a full-fledged type

full structure declaration

struct complex {
  double real;
  double imag;
} c1, c2, c3;

structure optional parts

all but the keyword struct are optional
- declare c1, c2, and c3 as having a structure type with no tag name
  struct { double real; double imag; } c1, c2, c3;
- cannot declare any other variables or functions of this type

forward declaration

declare just the tag name
struct complex;
- only needed in certain fairly rare situations

accessing members of structures

use the structure selection operator .
- on its left - a variable or object of structure type
- on its right - the name of one of the members of that structure
for example, c1.real is its real part and c1.imag is its imaginary part
references to the members of structure variables can appear anywhere
- on the right or left side of assignment operators
- like subscripted array references
c1.real = 1; c1.imag = c2.imag; c1.real = c2.real + c3.real;

operations on structures

roughly K&R Sec. 6.2
define structures
declare variables of structure type
assign entire structures
c1 = c2;

built-in operations on structures

pass structures as arguments to functions,
declare and define functions which return structures.
initialize a structure variable
- comma-separated list of values enclosed in braces {}
  struct complex c1 = {1, 2}; struct complex c2 = {3, 4};

operations on structures

anything else we have to write our own code

/* add two two complex numbers */
struct complex cpx_add(struct complex c1, struct complex c2)
{
  struct complex sum;
  sum.real = c1.real + c2.real;
  sum.imag = c1.imag + c2.imag;
  return sum;
}

we could then say things like
c1 = cpx_add(c2, c3)
in C++, it's possible to bind functions to the built-in operators
c1 = c2 + c2; /* NOT in C! */

pointers to structures

K&R Sec. 6.4
pointers to structures are particularly useful
pointers to structures are declared like any other pointers
struct complex *p1, *p2;

assigning is like asignments

p1 = &c2;
p2 = &c3;
*p1 = *p2;	/* copy c3 to c2 */
p1 = p2;	/* copy p1 to p2 */

pointers to structure members

first use * to get the structure pointed to, then . to access the desired member
(*p1).real
- since . has higher precedence than *, you must use parentheses
the -> operator is an alternative
p->real
- an exact equivalent

linked data structures

K&R Sec. 6.5
a structure contains a pointer to another instance of the same structure
- or perhaps a different structure

for example, a singly-linked list

struct listnode
{
  char *item;
  struct listnode *next;
};

a singly-linked list

the structure describes one node in a list
a list may consist of many nodes
in the example, each item in the list is a string
each node is linked to its successor by its next field
the compiler places a pointer to a structure inside that very same structure
- if you stuff an entire struct listnode into a struct listnode, it will explode
the next field of the last node in the list is NULL

a singly-linked tiny list

struct listnode node2 = {"world", NULL};
struct listnode node1 = {"hello", &node2};
struct listnode *head = &node1;

operate on a singly-linked list

print the list back out

struct listnode *lp;
for (lp = head; lp != NULL; lp = lp->next)
  printf("%s\n", lp->item);

declare another list pointer lp
cause it to step over each node in the list, in turn

iterate a singly-linked list

the three controlling expressions of a for loop are

initialize lp = head
test lp != NULL
increment pattern lp = lp->next

growing a singly-linked list

can grow on demand, in response to the input data

allocate nodes dynamically to grow the linked list

we won't know in advance how many of them we'll need
call malloc to allocate nodes

#include 
#include 

char *newword = "test";
struct listnode *newnode = malloc(sizeof(struct listnode));
if (newnode == NULL) {
  fprintf(stderr, "out of memory\n");
  exit(1);
}

newnode->item = newword;
newnode->next = head;
head = newnode;

the last two lines splice the new node in at the head of the list

prepending an item to a list

the list-prepending function returns a pointer to the new head of the list

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

struct listnode *prepend(char *newword, struct listnode *oldhead)
{
  struct listnode *newnode = malloc(sizeof(struct listnode));
  if (newnode == NULL) {
    fprintf(stderr, "out of memory\n");
    exit(1);
  }

  newnode->item = malloc(strlen(newword) + 1);
  if (newnode->item == NULL) {
    fprintf(stderr, "out of memory\n");
    exit(1);
  }
  strcpy(newnode->item, newword);

  newnode->next = oldhead;
  return newnode;
}

prepending an item to a list

it's possible to combine the two allocations

struct listnode *newnode;
if ((newnode = malloc(sizeof(struct listnode))) == NULL ||
    (newnode->item = malloc(strlen(newword) + 1)) == NULL)
{
  fprintf(stderr, "out of memory\n");
  exit(1);
}

logical operation evaluation

unique to the || and && operators
|| operator
- the left-hand side is evaluated first
- if the left-hand side is true, the right-hand is not evaluated
  - once the left-hand side is true, the final result is definitely going to be true
&& operator
- the left-hand side is evaluated first
- if the left-hand side is false, the right-hand is not evaluated
perfectly acceptable to rely on these guarantees

prepending an item to a list

if the first call to malloc fails, the second is not performed

struct listnode *newnode;
if ((newnode = malloc(sizeof(struct listnode))) == NULL ||
    (newnode->item = malloc(strlen(newword) + 1)) == NULL)
{
  fprintf(stderr, "out of memory\n");
  exit(1);
}

building a singly-linked list

read words or strings typed by the user, and prepend those to a list

#define MAXLINE 200

char line[MAXLINE];
struct listnode *head = NULL;
struct listnode *lp;

while(getline(line, MAXLINE) != EOF)
  head = prepend(line, head);

for(lp = head; lp != NULL; lp = lp->next)
  printf("%s\n", lp->item);

getline is the line-reading function we've been using
- can use the fgets function from the standard library instead
prints lines back out in the reverse order

other data structure

linked lists are only the simplest example of linked data structures
there are also queues, doubly-linked lists, trees, and circular lists

examples

photo editing

Maintained by Efi Fogel. Last modified: January 14 2003.

initialize	`lp = head`
test	`lp != NULL`
increment pattern	`lp = lp->next`