Overview of today s lecture. Quick recap of previous C lectures. Introduction to C programming, lecture 2. Abstract data type - Stack example

Size: px

Start display at page:

Download "Overview of today s lecture. Quick recap of previous C lectures. Introduction to C programming, lecture 2. Abstract data type - Stack example"

Britton Dickerson
6 years ago
Views:

1 Overview of today s lecture Introduction to C programming, lecture 2 -Dynamic data structures in C Quick recap of previous C lectures Abstract data type - Stack example Make Refresher: pointers Pointers Pointer arithmetic can be used in arrays Strings a special case of arrays int k = 42; int *ptr; ptr = &k; k ptr Refresher: header files Header files can be used when something should be declared or defined in several locations A header file should include things like constants, functional macros, and type declarations of functions and structs but could contain other things as well Header files can be used to specify ADT:s Declarations in the.h file, implementation in.c file Refresher: list.h Implementing a Stack in C #ifndef _LIST_H #define _LIST_H typedef struct node { NODE *LIST; LIST nil(); LIST cons(int i, LIST l); int head(list l); LIST tail(list l); int isempty(list l); void destroy(list *l); #endif This will only be included once! Defines a node in our list Constructor and functions Functionality: push, pop, top, destroy, etc... Can be implemented as a linked list of nodes We need to keep track of the top node Compared to the list example, we added a level of pointers top NULL 1

2 Why the extra pointer level? Structures we need, first version In the list example a pointer to a list is also a pointer to a element in the list Confusing implementation! Also, using that implementation, push and pop would change the pointer to the stack. NODE, *NODEPTR; *STACK; NODE = the node NODEPTR = pointer to the node STACK = pointer to the stack Implementing a Stack, first attempt Each method has a prototype in the header file The type is defined as a pointer to the struct Structures are defined in the header file stack1.h NODE, *NODEPTR; *STACK; STACK Stack(); void push(stack s, int i); int top(stack s); void pop(stack s); int isempty(stack s); void clear(stack s); void destroy(stack s); #include "stack1.h" STACK Stack() { STACK s = (STACK)malloc(sizeof(struct stack)); s->top = NULL; return s; void push(stack s, int i){ NODEPTR tmp = (NODEPTR)malloc(sizeof(NODE)); tmp -> item = i; tmp -> next = s -> top; s -> top = tmp; int top(stack s) { return s -> top -> item; stack1.c void pop(stack s){ NODEPTR tmp = s -> top; s -> top = s -> top ->next; free(tmp); int isempty(stack s){ return s -> top == NULL; void clear(stack s) { while(! isempty(s)) { pop(s); stack1.c void destroy(stack s) { clear(s); free(s); 2

3 Drawback An external user of our stack does not have to (and should not) know about our internal representation of the stack Second attempt, with integrity Each method still has a prototype in the header file The type is now defined as void * #include "stack2.h" stack2.h typedef void * STACK; STACK Stack(); void push(stack s, int i); int top(stack s); void pop(stack s); int isempty(stack s); void clear(stack s); void destroy(stack s); NODE, *NODEPTR; *STACKrep; STACK Stack() { STACKrep s = (STACKrep)malloc(sizeof(struct stack)); s->top = NULL; return s; void push(stack s, int i){ NODEPTR tmp = (NODEPTR)malloc(sizeof(NODE)); tmp -> item = i; tmp -> next = ((STACKrep) s) -> top; ((STACKrep) s) -> top = tmp; stack2.c Drawbacks No error handling Error handling What happens if we try to do pop or top on an empty stack? We can only store integers in the stack segmentation fault 3

4 Stack, third attempt: generic with integrity and error handling Nodes store void pointers, not int s Help methods are declared static (only visible within C file) Method names prefixed with stack_ to avoid conflicts Methods push and pop return int stack3.h #ifndef STACK_H #define STACK_H typedef void * STACK; /** Create a new empty stack. * Returns: An empty stack on success, * NULL if memory could not be allocated. */ STACK stack_create(); /** Pushes item into top of stack. * Pre: s was created by Stack(). * Post: The item has been pushed onto the top of s. * Returns: 0 on success, * 1 if memory could not be allocated. */ int stack_push(stack s, void * item); stack3.c #include "stack.h" struct stack_node { void *item; struct stack_node *next; ; struct stack { struct stack_node *top; ; STACK stack_create() { L U L E Å U N I V E R S I T Y struct O F T E stack C H N O *stack; L O G Y stack = (struct stack *)malloc(sizeof(struct stack)); if (stack!= NULL) stack->top = NULL; return (STACK)stack; int stack_push(stack s, void *i) { struct stack_node *n; n = stack_node_create(((struct stack *)s)->top, i); if (n!= NULL) { ((struct stack *)s)->top = n; return 0; return 1; stack3.c static struct stack_node * static int static struct stack_node * static void * stack_node_create(struct stack_node *next, void *item); stack_node_destroy(struct stack_node *n); stack_node_next(struct stack_node *n); stack_node_item(struct stack_node *n); void *stack_top(stack s) { if (!stack_isempty(s)) { return stack_node_item(((struct stack *)s)->top); else { return NULL; Make When writing large programs, it can be time consuming to compile the program make is a utility that simplifies the process Uses the makefile, which consists of targets, prerequisites, and commands. targetname: prerequisites command Simple make example main : main.o stack.o gcc -o main main.o stack.o main.o : stack.h main.c gcc -c main.c stack.o : stack.h stack.c gcc -c stack.c clean: rm -f main main.o stack.o 4

5 Make, cont Use definitions to make the makefile more general. Easier to reuse same file for different projects More general makefile # definitions PROGRAM = teststack SOURCES = teststack.c stack.c INCLUDES = stack.h # We reuse our definition of sources instead of naming all object files. OBJECTS = $(SOURCES:.c=.o) CFLAGS = -Wall CC = gcc $(PROGRAM) : $(OBJECTS) $(CC) -o $@ $(OBJECTS) C in Eclipse C/C++ plugin installed in the lab computers But there is a bug: You must use standard make project Lab 4 Write a priority queue in C Also, write a test program Same groups as in previous group labs Lab instructions out today Priority queues will be covered next lecture Summary Dynamic data types (stacks) make Lab 4 5

Chapter 19: Program Design. Chapter 19. Program Design. Copyright 2008 W. W. Norton & Company. All rights reserved.

Chapter 19: Program Design. Chapter 19. Program Design. Copyright 2008 W. W. Norton & Company. All rights reserved. Chapter 19 Program Design 1 Introduction Most full-featured programs are at least 100,000 lines long. Although C wasn t designed for writing large programs, many large programs have been written in C.