Week 07

Nerds You Should Know #6

1/45

The next in a series on famous computer-related people ...
 

 
Both are called "The Father of X" ... who are they?
(only one of them is computer-related)

... Nerds You Should Know #6

2/45

John von Neumann

1933-1953: Professor of Mathematics Princeton University Institute of Advanced Studies developed idea of "stored program" developed "memory/cpu" architecture (now called the "von Neumann architecture") first computer called "MANIAC" provided computational support for Manhattan Project (US atom bomb) early champion of scientific computing sceptical of "high-level programming languages"

Data and Memory

3/45

For the next two lectures ...

• work through a series of examples
• dealing with arrays, structs and linked lists
• to ensure that you understand properly
  • pointers, arrays, structures, linked lists
  • how to create objects
  • how objects exist in the C memory
  • how to read/write values of various types
  • how to manage memory via malloc() and free()
  • how to separate definitions of data types from their implementation

Data

4/45

Values of various types   (1,  -2,  3.14,  'A',  '1',  "abc")

The C language supports:

• atomic data: int, unsigned int, long, char, float, double
• arrays: indexed sequences of values of one type
• structs: collections of named heterogeneous values

• different kinds of values have different sizes (sizeof())
• all values are ultimately represented as a sequence of bytes

... Data

5/45

Data exists outside programs in files

A file is a sequence of bytes, accessed sequentially

The FILE * type represents a file stream in C

Every C program is connected to three streams:

• stdin,  stdout,  stderr

• getc,  putc,  fgets,  fputs,  scanf,  printf

... Data

6/45

Ways to input data into a program:

• command line arguments

  prompt$ prime1 719
  promtp$ ohce rise to vote sir
  

  • all command line arguments are strings

    
    argv[1] == "719"
    argv[1] == "rise" && argv[2] == "to" && argv[3] == "vote" && argv[4] == "sir"
    

  • must convert string to number, e.g. sscanf(argv[1], "%d", &number)
  • no need to convert to string or to char

... Data

7/45

Ways to input data into a program:

• stdin

  
  prompt$ ./floats
  Enter a number: 3.141593
  Enter a number: 2.718282
  The greater number is 3.141593
  

  • read data using scanf() or getchar() or fgets(...,stdin) etc.
  • can be redirected from files by < (on command line):

    
    prompt$ more xy.txt
    3.141593
    2.718282
    prompt$ ./floats < xy.txt
    Enter a number:
    Enter a number:
    The greater number is 3.141593
    

• Files (Week 10)

Memory

8/45

Memory is a very large array of bytes

• addressed from e.g. 0x00000000 to 0x7fffffff
• partitioned into code, global data, heap, stack
• can interpret single bytes as char values   (ASCII)
• can interpret 4-byte chunks as int or float values

• "regular" variables use a name to access a memory location
• pointer variables store addresses of memory location
• access via pointers requires "dereferencing" (*ptr)

... Memory

9/45

Within a program, data objects have scope and lifetime

Scope: region of program in which an object is known

• applies at compile-time
• affects how compiler interprets/translates program

• applies at execution time (run-time)
• determined by how/where object is defined

... Memory

10/45

Local variables and parameters:

• known only within the function where they are defined
• exist in stack only during an invocation of that function

• known to all functions after their definition
• exist in global data area for entire execution of program

• created by malloc(); accessible only via their address
• exist as soon as malloc()'d and until free()'d

Pointers

11/45

Pointer variables contain memory addresses

Pointers are typed   (know what kind of object they point to)

Using a pointer to access a simple memory object:

int  x, y, *xp;  xp = &x;  *xp = 5;  y = *xp+2;

Using a pointer to access a structured object:

typedef struct { int x; float y; char z; } Rec;

Rec r, *rp;  rp = &r;  (*rp).x = 5;  rp->z = 'm';

... Pointers

12/45

For a function to be able to change the "actual" value of a variable, we need to pass a pointer as a parameter.

• swap() – the wrong way

  
  void swap(int a, int b) {
      int temp;
      temp = a; a = b; b = temp;   // only the local "copies" of a and b will swap
  }
  
  void test(void) {
      int a = 5, b = 7;
      swap(a, b);
      printf("a = %d, b = %d\n", a, b);  // a and b will have their original value
  }
  

... Pointers

13/45

• swap() – the right way

  
  void swap(int *p, int *q) {
      int temp;
      temp = *p; *p = *q; *q = temp;   // will change the actual values of a and b
  }
  
  void test(void) {
      int a = 5, b = 7;
      swap(&a, &b);
      printf("a = %d, b = %d\n", a, b);  // a and b will now be successfully swapped
  }
  

Arrays

14/45

Arrays contain a sequence of values of the same type.

Each array is defined as:

#define N NumOfElems

ElemType a[N];

Elements are accessed via a[0], a[1], ... a[N-1]

The name a is equivalent to &a[0]   (constant pointer)

Iteration over arrays:

// index-based
int i; 
for (i = 0; i < N; i ++) { ... a[i] ... }
// pointer-based
ElemType *p;
for (p = a; p < &a[N]; p++) { ... *p ... }

Exercise: Implementing string.h

15/45

C strings are arrays of bytes, terminated by '\0'.

Implement the following operations from the string.h library:

typdef char *String;

int strlen(const String s);
String strcpy(String dest, const String src);

Use indexed-based iteration for strlen() and pointer-based iteration for strcpy().

The const indicates that we do not intend to change the input string.

Structs

16/45

Structs contain a named collection of values of various types.

Structs are defined as:

struct StructTag {
	Type1 FieldName1;
	Type2 FieldName2;
	...
	Typen FieldNamen;
};

Often, we define structs via a typedef:

typedef struct StructTag {...} StructTypeName;

Dynamic Data Structures

... Dynamic Data Structures

18/45

Dynamic data structures are built at runtime.

Linked lists are an example. They are defined as:

typedef struct node {
	DataT data;		// e.g. int data;
	struct node *next;
} NodeT;

... Dynamic Data Structures

19/45

Iterating over an existing linked list NodeT *list

NodeT *p = list;
while (p != NULL) {
	... p->data ...  // do something with the data    
	p = p->next;     // move forward
}

... Dynamic Data Structures

20/45

Creating a new list through iteration

• the wrong way

  NodeT *list;
  int i;
  for (i = 1; i < N; i += 2) {  // fill list with odd numbers
  	list = makeNode(i);   // create new node     
  	list = list->next;    // move forward
  }
  printList(list);
  

... Dynamic Data Structures

21/45

Creating a new list through iteration

• the right way

  NodeT *list, *head;
  head = makeNode(1);
  list = head;           // both point to the first node
  int i;
  for (i = 3; i < N; i += 2) {
  	list->next = makeNode(i);   // create and link new node  
  	list = list->next;          // move forward
  }
  printList(head);
  

... Dynamic Data Structures

22/45

Stacks are a form of linked lists used to model:

• moving boxes
• placing and removing many rings on a (single) finger
• putting plates away in the cupboard and then setting the table
• many cars going down a one-way street that is blocked and having to back out again
• calling functions in C
• page-visited history in a Web browser
• undo sequence in a text editor
• checking for balanced braces
• postfix calculator

... Dynamic Data Structures

23/45

Queues are a form of linked lists used to model:

• the checkout at a supermarket
• people standing at a ticket window
• people queueing to go onto a bus
• cars queueing to go onto a ferry
• objects flowing through a pipe (where they cannot overtake each other)
• messages, e.g. WhatsApp
• web page requests arriving at a web server
• printing jobs arriving at a printer

Abstract Data Types

Abstract Data Types

25/45

Abstract data types (ADTs) are ...

• an approach to implementing data types
• that separates interface from implementation
• clients of the ADT see only the interface (abstract view)
  • function signatures (prototypes) for all operations
  • semantics of operations (via documentation)
• the builder of the ADT provides an implementation
  • definition of the data structures (representation)
  • implementation for all operations as functions

Example: Quack ADT

26/45

Implement a data structure called Quack (QUeue and stACK):

• define the data structure
  • in terms of C structures such as integers, arrays, structs
• implement the operations on the data structure

... Example: Quack ADT

27/45

The operations are contained in a header file quack.h

typedef struct _node *Quack;

Quack createQuack(void);     // create and return Quack
void  push(int, Quack);      // put the given integer onto the quack
int   pop(Quack);            // pop and return the top element on the quack
int   isEmptyQuack(Quack);   // return 1 if Quack is empty, else 0
void  makeEmptyQuack(Quack); // remove all the elements on Quack
void  showQuack(Quack);      // print contents of Quack, from the top down

• push() and pop() are the core functions making a quack what it is
• we assume that the quack contains integers (could instead contain characters or structs)
• The type Quack is a pointer to a struct node
  • but what struct node?
  • depends on how the quack is implemented
  • which we cannot see from the header file

A Linked List Implementation of a Quack

28/45

• createQuack() creates a 'head' linked-list node that points to the quack.

// quackLL.c: a linked-list-based implementation of a quack
#include "quack.h"
#define HEADDATA -99999   // dummy data

struct _node {
	int data;
	struct _node *next;
};

Quack createQuack(void) {
	Quack head = (Quack)malloc(sizeof(struct _node));
	assert(head != NULL);
	head->data = HEADDATA;   // should never be used
	head->next = NULL;
	return head;
}

... A Linked List Implementation of a Quack

29/45

• push(data,qs) makes another node
• and populates it with data
• the new node becomes the new top of quack qs (so the quack is a stack)

void push(int data, Quack qs) {
	if (qs == NULL) {
		fprintf(stderr, "push: quack not initialised\n");
	} else {
		Quack newnode = (Quack)malloc(sizeof(struct _node));
		assert(newnode != NULL);
		newnode->data = data;
		newnode->next = qs->next;   // old top
		qs->next = newnode;         // new top
	}
}

... A Linked List Implementation of a Quack

30/45

• pop(qs) checks if the quack qs is not empty
• if so, retrieves the data of the top node
  • and the node is freed

int pop(Quack qs) {
	int retval = 0;
	if (qs == NULL) {
		fprintf(stderr, "pop: quack not initialised\n");
	} else if (isEmptyQuack(qs)) {
		fprintf(stderr, "pop: quack underflow\n");
	} else {
		Quack topnode = qs->next;   // top node must be there  
		retval = topnode->data;
		qs->next = topnode->next;   // new top
		free(topnode);              // free the old top
	}
	return retval;
}

... A Linked List Implementation of a Quack

31/45

Effect of createQuack() followed by three push() calls:

Exercise: Implementing Quack Functions

32/45

Implement the following functions for the Linked List implementation of quacks:

int   isEmptyQuack(Quack);   // return 1 if Quack is empty, else 0
void  makeEmptyQuack(Quack); // remove all the elements on Quack
void  showQuack(Quack);      // print contents of Quack, from the top down

Notes:

• all functions should check whether incoming quack qs has been initialised
• if qs->next == NULL the quack has been initialisd but is empty

Implementing Quack Functions for Queues

33/45

The quack implementations can be extended to queues

• still dealing with quacks
• only difference between stacks and queues:
  • in a stack, new nodes added at the top
  • in a queue, new nodes added at the bottom
• we only need one additional function, qush(), for queues
  • same prototype as push()

... Implementing Quack Functions for Queues

34/45

New interface quack.h

typedef struct _node *Quack;

Quack createQuack(void);     // create and return Quack
void  push(int, Quack);      // put the given integer onto the quack
void  qush(int, Quack);      // put the given integer onto the quack
int   pop(Quack);            // pop and return the top element on the quack
int   isEmptyQuack(Quack);   // return 1 if Quack is empty, else 0
void  makeEmptyQuack(Quack); // remove all the elements on Quack
void  showQuack(Quack);      // print contents of Quack, from the top down

... Implementing Quack Functions for Queues

35/45

qush(data,qs) in the Linked List Implementation

• makes another node
• and populates it with data
• the new node becomes the new bottom of quack qs (so the quack is a queue)

void qush(int data, Quack que) {
	if (que == NULL) {
		fprintf(stderr, "qush: quack not initialised\n");
	} else {
		Quack newnode = (Quack)malloc(sizeof(struct _node));
		assert(newnode != NULL);
		newnode->data = data;
		newnode->next = NULL;    // will become the new bottom
		Quack endnode = que;
		while (endnode->next != NULL) {   // go to end of list
			endnode = endnode->next;
		}
		endnode->next = newnode;         // new bottom
	}
}

Array Implementation of Quacks

An Array Implementation of a Quack

37/45

We can implement quacks as an array instead of a linked list.

Both use exactly the same .h file.

Quack is now a pointer to a struct that contains an array and an integer:

// quackAR.c: an array-based implementation of a quack
#include "quack.h"
#define HEIGHT 1000

struct _node {
   int array[HEIGHT];
   int top;
};

Quack createQuack(void) {
	Quack qs = (Quack)malloc(sizeof(struct _node));
	assert(qs != NULL);
	qs->top = -1;   // note the array in struct _node does not get initialised
	return qs;
}

Exercise: Re-implementing Quack Functions

38/45

Re-implement push(), qush() and pop() for the array implementation of quacks.

• push()
  • checks that there is a quack
  • checks that the array is not full (this is called quack overflow)
    • (unlike the linked-list implementation, where there is no maximum number of elements)
  • increments the index top
  • places the new data at this position in the array
• qush()
  • checks that there is a quack
  • checks that the array is not full
  • increments the index top and moves all elements up
  • places the new data at the bottom
• pop()
  • checks that there is a quack
  • checks there is no underflow
  • copies the element at top, decrements the value of top
  • returns the stored top element

... Exercise: Re-implementing Quack Functions

39/45

For the array implementation of quacks, re-implement the other functions

int   isEmptyQuack(Quack);   // return 1 if Quack is empty, else 0
void  makeEmptyQuack(Quack); // remove all the elements on Quack
void  showQuack(Quack);      // print contents of Quack, from the top down

Which of these functions can be exactly the same in both quack implementations?

Comparing the LL and AR Implementation

40/45

• you can overflow the array-based quack, but not the linked-list based quack
  • do you remember why?
    • (may of course create an 'artificial' maximum number of nodes for the linked-list version)
• a struct _node in a linked list implementation stores a quack element
• a struct _node in an array-based implementation stores the whole array
• the head node of the linked list version points to the top of the quack node

Exercise: Testing the LL and AR Implementations of Quacks

41/45

• Write a tester to call functions in the interface quack.h
• Build the executable using

  gcc -Wall -Werror -O quackLL.c tester.c
  

  to test the LL implementation

• Build the executable using

  gcc -Wall -Werror -O quackAR.c tester.c
  

  to test the AR implementation

Exercise: Josephus' Ring

42/45

1st century Jewish historian/philosopher/mathematician

The legend:

• Flavius Josephus was in a group of 41 people surrounded by the Romans
• group decided to rather die than surrender
• Flavius suggested forming a ring and going around clockwise
  • killing every 3rd person
  • until just one remains
  • who would commit suicide
• He placed himself at position 31

... Exercise: Josephus' Ring

43/45

• For example, if you have a ring of 12 people:

  
       2  3
     1      4
  12          5
  11          6
    10      7
       9  8
  

  and you start counting at 1, people would be removed in the order:

  
  3 6 9 12 4 8 1 7 2 11 5
  

• Implement Josephus' Scheme using a quack as a queue

Tips for Next Quiz

44/45

• Lab exercises week 6-8 are a good preparation
• 2 programs
• Use scanf to read lines with correctly formatted input data
  
  Example: You can read input of the form

  comp 1921 87.5
  

  via

  char  str[BUFSIZ];
  int   i;
  float f;
  scanf("%s %d %f", str, &i, &f);
  

... Tips for Next Quiz

45/45

Sample practice question

• Use list.h and list.c
  to write a program that
  • creates a linked list from all odd integers between 1 and 99
  • inserts the even numbers from 2 to 100 at the right place
  • deletes every multiple of 3
  • prints the resulting list after each stage

  1->3->5->7->9->...->99
  1->2->3->4->5->6->7->8->9->10->...->99->100
  1->2->4->5->7->8->10->...->100
  

• Use only 1 linked list. Do not use any other data structure
• Avoid memory leaks

Produced: 4 Sep 2016