Intro to list in C: creating list elements, simple linking and traversal

Review: reserving memory cells for linked list elements (in Java)

Recall that in Java, the new operator is used to "create" new "objects":

The effect of the new operator is as follows:

Reserve memory cells (= find usused memory cells and mark them as used) for the object
Return the address of the first memory cell that was reserved

Memory management in C - it is very different from Java

Fact:

The C programming language does not have the new operator to reserve memory cells

More importantly:

The C programming language does not have a garbage collection mechanism to clean up inaccessible variables ("objects")
(Recall from CS170 that inaccessible object (= "garbage") in Java are clean up peridically by the garbage collector that is built-in in Java: click here )

Moral of this story:

C provides only very minimal support for object creation (= reserve memory cells) and object destruction (= un-reserve memory cells)
You (the C programmer) must de-allocate (un-reserve) memory cells when a linked list element is no longer used !!!

Managing memory cells in C:

The standard C library contains several functions to let the C programmer (= you) manage memory cells
Repeated warning:

Reserving memory cells

Memory allocation:

Reserving memory cells is called "memory allocation"

C library function:

#include <stdlib.h> // You must include this header file // to obtain the function declaration void* malloc(size_t nBytes): Effect: reserve nBytes memory cells Returns: the address of the first memory location that was reserved The type void* means that it can be assigned to any kind of reference typed variable

Illustrated usage:

Suppose we have a reference variable p:
The blue-colored memory cells are unused
The statement p = malloc(16) will:

Note:

Typically, the reference variable p will point to a struct variable

You can access the members inside the struct using:

(*p).varName // long form or: p->varName // short hand

Example:

#include <stdio.h> #include <stdlib.h> // Contains the declaration of malloc() /* ------------------------ Structure definition ------------------------ */ struct BankAccount { int accNum; double balance; }; int main(int argc, char *argv[]) { struct BankAccount* p; p = malloc( 16 ); // Create one BankAccount struct variable (*p).accNum = 123; // Long form to access a member variable p->balance= 400; // Short form to access a member variable printf("p->accNum = %d p->balance = %f\n", p->accNum, p->balance); }

Example Program: (Demo above code)
- Prog file: click here
How to run the program:

Better way to allocate memory space: use sizeof()

To avoid computing the amount of memory cells needed, you can use the sizeof() operation in C:

int main(int argc, char *argv[]) { struct BankAccount* p; p = malloc( sizeof(struct BankAccount) ); // sizeof(struct BankAccount) = 16 (*p).accNum = 123; // Long form to access a member variable p->balance= 400; // Short form to access a member variable printf("p->accNum = %d p->balance = %f\n", p->accNum, p->balance); }

Un-reserving a previously reserve linked list element

Syntax:

#include <stdlib.h> // You must include this header file // to obtain the function declaration free( memoryAddress ); Effect: unreserve (de-allocate) the previously allocated memory block that starts at memoryAddress

Iluustrated:

Suppose the memory reservation is as follows:
After the statement free(p) (which will invoke free(2024)), the memory reservation will be as follows:

Note:

Example C program:

#include <stdio.h> #include <stdlib.h> /* ------------------------ Structure definition ------------------------ */ struct BankAccount { int accNum; double balance; }; int main(int argc, char *argv[]) { struct BankAccount* p; p = malloc( sizeof(struct BankAccount) ); // (1) (*p).accNum = 123; // Long form to access a member variable p->balance= 400; // Short form to access a member variable printf("p->accNum = %d p->balance = %f\n", p->accNum, p->balance); /* ================================================== Unreserve memory that was allocated at step (1) ================================================== */ free(p); }

Example Program: (Demo above code)
- Prog file: click here
How to run the program:

The empty list

The empty list is indicated by setting the "head" variable to the special value NULL ("nowhere"):

#include <stdio.h> // NULL is defined inside this header file head = NULL;

Adding to the front of the list

Note:

The insert at head teachique was discussed in CS171
I will only show you the syntax in C on how to insert at head of a list

Example C program: insert at head

#include <stdio.h> #include <stdlib.h> /* ------------------------ List element definition ------------------------ */ struct ListElem { int value; struct ListElem* next; }; int main(int argc, char *argv[]) { struct ListElem* head; // Head of list struct ListElem* p; // Help variable to allocate new list element head = NULL; // Empty list /* ======================================================== Insert at head technique: 1. create new list element p put values in the payload area... 2. make p point to first element in list 3. make head point to new list element ======================================================== */ p = malloc( sizeof(struct ListElem) ); // (1) p->value = 123; // Payload... p->next = head; // (2) head = p; // (3) }

Example Program: (Demo above code)
- Prog file: click here
How to run the program:

Traversing a linked list

Algorithm to traverse the linked list starting at the head element:

p = head; // Start at first element while ( p != NULL ) { /* ------------------------------------ Put code here to do something with the list element (*p) E.g.: (*p).value = ... or p->value = .... ------------------------------------- */ p = p->next // Visit next element in list }

C function that prints all elements in a list:

void printList( struct ListElem* h ) { while ( h != NULL ) { printf(" %d\n", h->value ); // Print h = h->next; // Go to next element in list } printf("\n"); }

Example Program: (Demo above code)
- Prog file: click here
How to run the program: