10, September 1997
September 10, 1997
Everything is on the Web
http://www.cs.princeton.edu/courses/cs217 Texts, Contact Information, Assignments, Lecture slides ... No handouts in class (except blank paper for quizzes) 9 assignments, including a nal project due on Monday at midnight. N O E X T E N S I O N S . A few easy quizzes (15 min each, in-class) Midterm No nal
A stack A hash table
Interfaces and Implementations
A big program is made up of many small modules Each module implements (does) one thing
Mathematical functions
Interfaces specify what a module does
Implementations specify how a module does it
Copyright
1995 D. Hanson, K. Li & J.P. Singh
Computer Science 217: Everything is on the Web
Page 2
Copyright
1995 D. Hanson, K. Li & J.P. Singh
Computer Science 217: Interfaces and Implementations
Page 4
September 10, 1997
September 10, 1997
About COS 217
Goals: Prepare for other CS courses (and summer jobs) Learn everything you need to know about ANSI C Master the art of programming
- design method, abstraction, interfaces and implementations, style - writing efcient programs
This Course is About ...
Modules, interfaces and implementations
Add_Box_To_Picture (Box,Picture,Position) { ... ...
Drawing_Program() {
...
do other things Algorithm to implement function ... ... } }
Introduction to aspects of other courses Low-level workings of a computer (more in COS 471))
- SUNs SPARC architecture and instruction set
Add_Box_to_Picture(B,P,Pos)
...
do other things
Assembly language programming (more in COS 320 and COS 471) Operating systems (more in COS 318 and COS 461)
- Programming using operating system services
Whats the module, interface, implementation, client?
Object-oriented programming
Copyright
1995 D. Hanson, K. Li & J.P. Singh
Computer Science 217: About COS 217
Page 1
Copyright
1995 D. Hanson, K. Li & J.P. Singh
Computer Science 217: This Course is About ...
Page 3
September 10, 1997
September 10, 1997
More on Interfaces and Implementations
One interface, perhaps many implementations. Why?
efciency, different algorithms for different situations, machine dependences
Interfaces
Modules export interfaces, clients import them
Interfaces specify what clients may use or read
Everything a client needs to see
Data types, variables, function interfaces, text specications, ...
Interface and its implementations must agree Clients need see only the interface
do not need to understand implementation to use the module may have only the object code for an implementation why might a client want to know more than the interface?
They hide implementation details and algorithms
In C, an interface is usually a single .h le; e.g. stack.h
Interfaces are contracts between their implementations and clients
Client responsibilities Checked runtime errors : : Unchecked runtime errors Performance criteria : :
rules clients must follow to ensure correctness
Clients share interface and implementations
avoids duplication and bugs --- implemented once, used often
implementations guarantee to detect them, but they are bugs
implementations might not detect them
implementations must meet them
What does this sound like in your programming experience?
Copyright 1995 D. Hanson, K. Li & J.P. Singh Computer Science 217: More on Interfaces and Implementations Page 6
Examples from the real world?
Copyright 1995 D. Hanson, K. Li & J.P. Singh Computer Science 217: Interfaces
Page 8
September 10, 1997
September 10, 1997
Interfaces and Implementations: An Example
Driving an automobile
Client, Interface and Implementation: A Stack
Interface:
steering wheel gears brake accelerator clutch?
Implementation: engine and all its details
Copyright
1995 D. Hanson, K. Li & J.P. Singh
Computer Science 217: Interfaces and Implementations: An Example
Page 5
Copyright
1995 D. Hanson, K. Li & J.P. Singh
Computer Science 217: Client, Interface and Implementation: A Stack
Page 7
September 10, 1997
September 10, 1997
Abstract Data Types (ADTs)
Abstract data type: A kind of interface A data type, plus Operations on entities ("variables") of that type Data type: a class of values
integers, reals, lists of integers, binary search trees, lookup tables ...
#include <assert.h> #include <stdlib.h> #include "stack.h" #define T Stack_T struct T { void *val; T next; };
An Implementation of the Stack ADT
stack.c
T Stack_new(void) { T stk = calloc(1, sizeof *stk); assert(stk); return stk; }
int Stack_empty(T stk) { assert(stk); return stk->next == NULL; }
Abstract: Operations permitted are indept. of internal representation Advantages
Restricts manipulation of the values to a set of specied operations Hides how the ADT is represented
void Stack_push(T stk, void *x) { T t = malloc(sizeof *t); assert(t); assert(stk); t->val = x; t->next = stk->next; stk->next = t; }
void *Stack_pop(T stk) { void *x; T s; assert(stk && stk->next); x = stk->next->val; s = stk->next; stk->next = stk->next->next; free(s); return x; }
void Stack_free(T *stk) { T s; assert(stk && *stk); for ( ; *stk; *stk = s) { s = (*stk)->next; free(*stk); }
A key idea behind object-oriented programming BUT GOOD PROGRAMMING PRACTICE REGARDLESS OF LANGUAGE
Copyright 1995 D. Hanson, K. Li & J.P. Singh Computer Science 217: Abstract Data Types (ADTs) Page 10
Convention: In implementation, T is abbreviation of X_T for ADT X.
Copyright 1995 D. Hanson, K. Li & J.P. Singh
Computer Science 217: An Implementation of the Stack ADT
Page 12
September 10, 1997
September 10, 1997
Implementations
Implementations instantiate an interface In C, implementation source code is in .c les The interface is the key Some important things to do:
De-couple clients from implementations - Changes in an implementation do not affect clients - Implementations can shared, be e.g. via libraries
An ADT Example: A Stack Again
The interface stack.h denes a stack ADT and its operations
#ifndef STACK_INCLUDED #define STACK_INCLUDED typedef struct Stack_T *Stack_T; extern extern extern extern extern Stack_T Stack_new(void); int Stack_empty(Stack_T stk); void Stack_push(Stack_T stk, void *x); void *Stack_pop(Stack_T stk); void Stack_free(Stack_T *stk);
/* It is a checked runtime error to pass a NULL Stack_T or Stack_T* to any routine in this interface or call Stack_pop with an empty stack. */ #endif
The type Stack_T is an opaque pointer type Clients can pass a
Hide implementation details
- Prevents dependency on specic representations and algorithms
Stack_T around, but cant look inside one
Separate use of an interface from its implementations
- User should read specications, not programs
Stack_ is a disambiguating prex A convention that helps avoid name collisions in large programs
Question: What does #ifndef STACK_INCLUDED do?
1995 D. Hanson, K. Li & J.P. Singh Computer Science 217: Implementations Page 9 Copyright 1995 D. Hanson, K. Li & J.P. Singh Computer Science 217: An ADT Example: A Stack Again
Copyright
Page 11
September 10, 1997
September 10, 1997
Assertions
Even checked runtime errors are bugs assert(e) issues a message and aborts the program if e is 0
int Stack_empty(T stk){ assert(stk); return stk->next == NULL; }
The Standard C Library Interfaces
The ANSI C interfaces (See H&S, Ch 10)
assert.h ctype.h errno.h float.h limits.h locale.h math.h setjmp.h signal.h stdarg.h stddef.h stdio.h stdlib.h string.h time.h assertions character mappings error numbers metrics for oating types metrics for integral types locale specics math functions non-local jumps signal handling variable length argument lists standard denitions standard I/O standard library functions string functions date/time functions
assert.h (approximately):
#ifdef NDEBUG #define assert(e) ((void)0) #else #define assert(e) ((void)((e)|| (fprintf(stderr, \ "assertion failed: file %s, line %d\n", \ __FILE__, __LINE__), abort(), 0))) #endif
lcc -DNDEBUG foo.c ...
Be careful using assertions e may not be executed if assertions are turned off (why would you do this?) dont put code with side effects in an assertion
An ANSI C library provides the implementations re-use, dont re-implement; use libraries
Copyright 1995 D. Hanson, K. Li & J.P. Singh Computer Science 217: The Standard C Library Interfaces
Dont want program to crash without a diagnostic (safe programming)
Copyright 1995 D. Hanson, K. Li & J.P. Singh Computer Science 217: Assertions Page 14
Page 16
September 10, 1997
September 10, 1997
A Sample Client of the Stack ADT
test.c
#include <stdio.h> #include <stdlib.h> #include "stack.h" int main(int argc, char *argv[]) { int i; Stack_T s = Stack_new(); for (i = 1; i < argc; i++) Stack_push(s, argv[i]); while (!Stack_empty(s)) printf("%s\n", Stack_pop(s)); Stack_free(&s); return EXIT_SUCCESS; }
Programming Style
includes stack.h (so it can use the stack ADT)
Variable names, indentation, program structure... Why? Who reads your programs?
compiler users other programmers
Which ones care about style? Which ones do you program for?
Copyright
test.o is a client of stack.h changing stack.h must re-compile test.c test.o is loaded with stack.o lcc test.o stack.o stack.o is also a client of stack.h changing stack.h must re-compile stack.c
1995 D. Hanson, K. Li & J.P. Singh Computer Science 217: A Sample Client of the Stack ADT Page 13
Difference between "macho" programmer and good programmer Well talk more about style later
Copyright 1995 D. Hanson, K. Li & J.P. Singh Computer Science 217: Programming Style
Page 15
September 10, 1997
The Standard C Library, contd
Utility functions stdlib.h:
atof, atoi, strtod, rand, qsort, getenv, calloc, malloc, realloc, free, abort, exit, ...
String handling string.h:
strcmp, strncmp, strcpy, strncpy strcat, strncat, strchr, strrchr, strlen, ... memcpy, memmove, memcmp, memset, memchr
Character classication ctype.h:
isdigit, isalpha, isspace, ispunct, isupper, islower, toupper, tolower, ...
Mathematical functions math.h:
sin, cos, tan, asin, acos, atan, atan2, ceil, floor, fabs sinh, cosh, tanh, exp, log, log10, pow, sqrt,
Variable-length argument lists stdarg.h:
va_list, va_start, va_arg, va_end
Non-local jumps setjmp.h:
jmp_buf, setjmp, longjmp
Copyright 1995 D. Hanson, K. Li & J.P. Singh Computer Science 217: The Standard C Library, contd Page 18
September 10, 1997
September 10, 1997
Libraries
The Standard I/O Library
stdio.h specifies a FILE*, a good example of an ADT So why dont people always just use libraries? Its a great idea, but often not implemented well Efciency Specic functionality Mastering big libraries is hard Library design is difcult: generality, simplicity and efciency Libraries may have implementation bugs
extern FILE *stdin, *stdout, *stderr; extern extern extern extern extern extern extern extern extern extern extern extern extern extern extern extern extern extern extern extern
int fclose(FILE *); FILE *fopen(const char *, const char *); int fprintf(FILE *, const char *, ...); int fscanf(FILE *, const char *, ...); int printf(const char *, ...); int scanf(const char *, ...); int sprintf(char *, const char *, ...); int sscanf(const char *, const char *, ...); int fgetc(FILE *); char *fgets(char *, int, FILE *); int fputc(int, FILE *); int fputs(const char *, FILE *); int getc(FILE *); int getchar(void); char *gets(char *); int putc(int, FILE *); int putchar(int); int puts(const char *); int ungetc(int, FILE *); int feof(FILE *);
Copyright 1995 D. Hanson, K. Li & J.P. Singh Computer Science 217: Libraries Page 17
Do you need to know what a FILE* looks like?
Copyright 1995 D. Hanson, K. Li & J.P. Singh Computer Science 217: The Standard I/O Library
Page 19