Week 05

Week 05 1/48

Things to Note ...

Reminder that in order to get lab marks, lab exercises X must be
- submitted in lab X and demonstrated to your tutor
- or submitted by Sunday 11:59pm at the end of week X
  - and demonstrated in lab X+1

In This Lecture ...

Dynamic Memory Management (Ch.10)
Linked Lists (Ch.10)

Coming Up ...

Stacks and queues (Ch.10)

Nerds You Should Know #4 2/48

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

Nice hat/shirt ... but what has he done since 1971?

... Nerds You Should Know #4 3/48

Michael Hart

Founder of Project Gutenberg

books for everyone for free
only out-of-copyright books
available in plain ascii text
typed/scanned by volunteers
99.9% accessible, 99.9% correct

Currently have > 49,000 texts online, e.g.
- "Hamlet", "Macbeth", ... by William Shakespeare
- "Faust", ... by Johann Wolfgang von Goethe
- "The Art of War" by Sun Tzu
- "The Magic Pudding" by Norman Lindsay
- "CIA World Factbook", 1990-2010
- "Chromosome Y", Human Genome Project

Dynamic Memory Allocation 4/48

Statically allocated objects ...

are allocated by the compiler (to global/stack areas)
have a fixed size which is known at compile time
have a lifetime determined by location (global/stack)

Dynamically allocated objects ...

are allocated by the executing program (in heap)
have a size which is known at allocation time
exist until explicitly removed by program

... Dynamic Memory Allocation 5/48

Example: write a function lowerCase() to return a lower-cased version of a string

char *old = "This is MY string.";
char *new;

new = lowerCase(old);

print("%s\n%s\n", old, new);
// Output:
// This is MY string.
// this is my string.

Notes:

the old string is unchanged, so the function is making a new copy

old is a pointer to a string in the global data area

new has no string buffer unless it's made to point at one

tolower(ch) function in ctype.h is useful here

... Dynamic Memory Allocation 6/48

Attempt #1: use a local string buffer

char *lowerCase(char *str) {
	char *cp;  // input string cursor
	char *op;  // output string cursor
	char out[BUFSIZ];  // output string buffer
	
	op = out;
	for (cp = str; *cp != '\0'; cp++) {
		*op = tolower(*cp);
		op++;
	}
	*op = '\0';
	return out;  // what is the precise effect?
}

BUG: the out variable is removed when lowerCase() returns.

... Dynamic Memory Allocation 7/48

Attempt #2: user-supplied string buffer (different interface)

char *old = "This is MY string.";
char new[BUFSIZ];
...
lowerCase(old, new);
...
void lowerCase(char *in, char *out) {
	char *cp, *op = out;
	for (cp = in; *cp != '\0'; cp++) {
		*op = tolower(*cp);
		op++;
	}
	*op = '\0';
}

More common way of writing loop body: *op++ = tolower(*cp);

... Dynamic Memory Allocation 8/48

Attempt #3: dynamically allocated buffer

char *lowerCase(char *str) {
	char *cp;   // input string cursor
	char *op;   // output string cursor
	char *out;  // output string buffer
	
	out = (char *)malloc(strlen(str)+1);
	assert(out != NULL);
	op = out;
	for (cp = str; *cp != '\0'; cp++) {
		*op = tolower(*cp);
		op++;
	}
	*op = '\0';
	return out;  // what is the precise effect?
}

Memory Management 9/48

void free(void *ptr)

releases a block of memory allocated by malloc()
*ptr is a dynamically allocated object
if *ptr was not malloc()'d, chaos will follow

Things to note:

the contents of the memory block are not changed
all pointers to the block still exist, but are not valid
the memory may be re-used as soon as it is free()'d

... Memory Management 10/48

Warning! Warning! Warning! Warning!

Careless use of malloc() / free() / pointers

can mess up the data in the heap
so that later malloc() or free() cause run-time errors
possibly well after the original error occurred

Such errors are very difficult to track down and debug.

Be very careful with your use of malloc() / free() / pointers.

... Memory Management 11/48

Given a pointer variable:

you can check whether its value is NULL
you can (maybe) check that it is an address
you cannot check whether it is a valid address

... Memory Management 12/48

Typical usage pattern for dynamically allocated objects:

// single dynamic object e.g. struct
size_t size = sizeof(Type);
Type *ptr = (Type *)malloc(size);
assert(ptr != NULL);
... use object referenced by ptr e.g. ptr->name ...
free(ptr);

// dynamic array with "nelems" elements
int nelems = NumberOfElements;
size_t eSize = sizeof(ElemType);
ElemType *arr = (Type *)malloc(nelems*eSize);
assert(arr != NULL);
... use array referenced by arr e.g. arr[4] ...
free(arr);

Exercise: Flatten a 2d Array 13/48

Implement a function

int *flattenArray(Matrix matrix, int m, int n)

which

takes a 2d m×n integer matrix
returns a pointer to a dynamic 1d array made by concatenating the rows

Memory Leaks 14/48

Well-behaved programs do the following:

allocate a new object via malloc()
use the object for as long as needed
free() the object when no longer needed

A program which does not free() each object before the last reference to it is lost contains a memory leak.

Such programs may eventually exhaust available heapspace.

... Memory Leaks 15/48

Example function with memory leak:


int median(int v[], int n) {
        int i, j, min, tmp, *sorted;

        sorted = (int *)malloc(n*sizeof(int));
        assert(sorted != NULL);

	for (i = 0; i < n; i++) { sorted[i] = v[i]; }

        for (i = 0; i < n; i++) {   // a simple sorting algorithm
                min = i;
                for (j = i+1; j < n; j++) {
                        if (sorted[j] < sorted[min]) { min = j; }
                }
		tmp = sorted[i];
                sorted[i] = sorted[min];
		sorted[min] = tmp;
        }
        return sorted[n/2];
}

The array referenced by sorted exists after function returns.

... Memory Leaks 16/48

Example function without memory leak:


int median(int v[], int n) {
        int i, j, min, tmp, med, *sorted;

        sorted = (int *)malloc(n*sizeof(int));
        assert(sorted != NULL);

	for (i = 0; i < n; i++) { sorted[i] = v[i]; }

        for (i = 0; i < n; i++) {   // a simple sorting algorithm
                min = i;
                for (j = i+1; j < n; j++) {
                        if (sorted[j] < sorted[min]) { min = j; }
                }
		tmp = sorted[i];
                sorted[i] = sorted[min];
		sorted[min] = tmp;
        }
	med = sorted[n/2];
	free(sorted);
        return med;   // would return sorted[n/2]; work?
}

The array referenced by sorted is cleaned up before function returns.

Summary: Memory Management Functions 17/48

void *malloc(size_t nbytes)

aim: allocate some memory for a data object
attempt to allocate a block of memory of size nbytes in the heap
if successful, returns a pointer to the start of the block
if insufficient space in heap, returns NULL

Things to note:

the initial contents of the memory block are random
returned address should be cast to appropriate pointer type

... Summary: Memory Management Functions 18/48

void free(void *ptr)

releases a block of memory allocated by malloc()
*ptr is a dynamically allocated object
if *ptr was not malloc()'d, chaos will follow

Things to note:

the contents of the memory block are not changed
all pointers to the block still exist, but are not valid
the memory may be re-used as soon as it is free()'d

... Summary: Memory Management Functions 19/48

void *calloc(size_t nelems, size_t nbytes)

aim: create a new array with memory zero'd
nelems is the number of elements
nbytes is the size of each element
allocates a memory block of size nelems*nbytes bytes
if successful, all bytes in memory block are set to zero
if insufficient memory, returns NULL

... Summary: Memory Management Functions 20/48

void *realloc(void *ptr, size_t nbytes)

aim: increase the size of an array
allocates a memory block of size nbytes bytes
if successful, copies all data from *ptr object into it
after copying, performs free(ptr)
assumes that nbytes is larger than size of *ptr object
if insufficient memory, returns NULL and does not free

Exercise: Generic Matrix Library 21/48

Use dynamically allocated memory to implement the following library of Matrix operations:

typedef struct { int nrows, ncols; float **data; } Matrix;
int readMatrix(Matrix *);
void printMatrix(Matrix);
void copyMatrix(Matrix, Matrix);
void transMatrix(Matrix, Matrix);
void addMatrix(Matrix, Matrix, Matrix);
void mulMatrix(Matrix, Matrix, Matrix);

Notes:

readMatrix reads nrows, ncols, then the data
can only add matrices with equal rows and columns
can only multiply an n×m matrix with an m×p matrix

Dynamic Structures

Static/Dynamic Sequences 23/48

We have studied arrays extensively

fixed size collection of heterogeneous elements
can be accessed via index or via "moving" pointer

The "fixed size" aspect is a potential problem:

how big to make the array? (big ... just in case)
what to do if it fills up? (realloc() may help)

The rigid sequence is another problems:

inserting/deleting an item in middle of array

... Static/Dynamic Sequences 24/48

Inserting a value into a sorted array (insert(a,&n,4)):

... Static/Dynamic Sequences 25/48

Deleting a value from a sorted array (delete(a,&n,3)):

Exercise: Insert/Delete in Sorted Array 26/48

Implement the above insert and delete operations:

// insert value v into array a of length n

void insert(int *a, int *n, int v);

// delete value v from array a of length n

void delete(int *a, int *n, int v);

What special cases do we need to consider?

Dynamic Sequences 27/48

The problems with using arrays can be solved by

allocating elements individually
linking them together as a "chain"

Benefits:

insertion/deletion have minimal effect on list overall
only use as much space as needed for values

Self-referential Structures 28/48

To realise a "chain of elements", need a node containing

a value
a link to the next node

In C, we can define such nodes as:

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

... Self-referential Structures 29/48

When definining self-referential types with typedef

typedef struct node {
	int data;
	struct node *next;
} NodeT;

typedef struct node NodeT;
struct node {
	int data;
	NodeT *next;
};

... Self-referential Structures 30/48

Note that the following definition does not work:

typedef struct {
	int data;
	NodeT *next;
} NodeT;

Because NodeT is not yet known (to the compiler) when we try to use it to define the type of the next field.

The following is also illegal in C:

struct node {
	int data;
	struct node recursive;    
};

Because the size of the structure would have to satisfy sizeof(struct node) = sizeof(int) + sizeof(struct node) = ∞.

Linked Lists 31/48

To represent a chained (linked) list of nodes:

we need a pointer to the first node
each node contains a pointer to the next node
the next pointer in the last node is NULL

... Linked Lists 32/48

Linked lists are more flexible than arrays:

values do not have to be adjacent in memory
values can be rearranged simply by altering pointers
the number of values can change dynamically
values can be added or removed in any order

Disadvantages:

it is not difficult to get pointer manipulations wrong
each value also requires storage for next pointer

Memory Storage for Linked Lists 33/48

Linked list nodes are typically located in the heap

because nodes are dynamically created

Variables containing pointers to list nodes

are likely to be local variables (in the stack)

Pointers to the start of lists are often

passed as parameters to function
returned as function results

... Memory Storage for Linked Lists 34/48

Iteration over Linked Lists 35/48

When manipulating list elements

typically have pointer p to current node (NodeT *p)
to access the data in current node: p->data
to get pointer to next node: p->next

To iterate over a linked list:

set p to point at first node (head)
examine node pointed to by p
change p to point to next node
stop when p reaches end of list (NULL)

... Iteration over Linked Lists 36/48

Standard method for scanning all elements in a linked list:

NodeT *list;  // pointer to first Node in list
NodeT *p;     // pointer to "current" Node in list

p = list;
while (p != NULL) {
	... do something with p->data ...
	p = p->next;
}

// which is frequently written as

for (p = list; p != NULL; p = p->next) {
	... do something with p->data ...
}

... Iteration over Linked Lists 37/48

... Iteration over Linked Lists 38/48

Exercise: Print a List 39/48

Write a function that will

given a pointer to the first node in the list:
print all values stored in the list
separated by a space, terminated by '\n'

Use the following function interface:

void printList(NodeT *list) { ... }

Exercise: Length of List 40/48

Write a function that will

given a pointer to the first node in the list:
return a count of the number of nodes in the list
return zero if the list is empty

Use the following function interface:

int length(NodeT *list) { ... }

Recall: To iterate over a linked list,

set p to point at first node (head)

examine node pointed to by p

change p to point to next node

stop when p reaches end of list (NULL)

List Type 41/48

In the previous examples, we define a list

using a pointer to the first node in the list

Thus, a common typedef for a list type is:

typedef struct node {
	int data;
	struct node *next;
} NodeT;

typedef NodeT *List;

The previous functions could then be defined as:

void printList(List list) { ... }
int length(List list) { ... }

... List Type 42/48

Common variations on basic List type ...

Store pointers to both first (head) and last (tail) nodes:

typedef struct { NodeT *head; NodeT *tail; } List;

Include a length counter:

typedef struct { NodeT *head; int length; } List;

List Operations 43/48

A typical list datatype would involve operations:

make a new empty list
print all list elements
insert a new value into the list
- at the head / at the tail / maintaining sorted order
delete a value from the list
- from the head / from the tail / delete specified value
search for a node with a specified value
free all list elements

... List Operations 44/48

An important operation used by list operations:

make a new node containing a specified value

Implementation:

NodeT *makeNode(int v) {
	NodeT *new;
	new = (NodeT *)malloc(sizeof(NodeT));
	assert(new != NULL);
	new->data = v;
	new->next = NULL;
	return new;
}

... List Operations 45/48

A new node can be inserted at the end of a list:


NodeT *insertTail(NodeT *head, int d) {
   // create new node with data
   NodeT *new = makeNode(d);
   if (head != NULL) {            // check if at least 1 node
      NodeT *cur;
      cur = head;                 // start at the head
      while (cur->next != NULL) { // this must be defined
         cur = cur->next;
      }
      cur->next = new;            // cur->next was NULL
   } else {
      head = new;                 // if no list, list = new
   }
   return head;
}

... List Operations 46/48

Another important list operation:

free all the nodes in a list

Implementation:

void freeList(NodeT *list) {
	NodeT *cur;

	cur = list;
	while (cur != NULL) {
		NodeT *tmp = cur->next;
		free(cur);
		cur = tmp;
	}
}

Exercise: Sorted List Type 47/48

Implement a new SortedIntList data type

using a linked list

Implement a library based on this:

typedef ... SortedIntList;
SortedIntList mkEmpty();
void printList(SortedIntList);
SortedIntList insert(SortedIntList, int);
SortedIntList delete(SortedIntList, int);

Tips for Next Week's Lab 48/48

Memory management, Linked lists

Concatenate all command line arguments into a string on the heap
- allocate sufficient space using malloc()
- always cast the result of malloc()
```
char *heap = (char *)malloc( ... )
```
- always free memory to avoid memory leaks
```
free(heap);
```
Same tips apply to heapsum.c

Linked lists

understand and use functions from lecture


NodeT *makeNode(int value);
freeList(NodeT *head);
NodeT *insertTail(NodeT *head, int value);

modify function from lecture
```
void printList(NodeT *head);
```
sample output: 10->20->30->40

Produced: 19 Aug 2016