1. CSC 237 - Data Structures, Fall, 2008 Welcome to Data Structures! Tuesday, September 2 uses Monday’s schedule!

2. Who am I? Dr. Dale E. Parson (a.k.a. Professor Parson), http://faculty.kutztown.edu/parson/ http://faculty.kutztown.edu/parson/ In a previous life I was an AT&T technician and then a Bell Labs software engineer for over 25 years. Also, I consult as Amplified Computing. I have taught at Albright College, Millersville University and Lehigh University. This is, in my opinion, the central course of the CSC curriculum. I have taught it at Albright and Millersville.

3. Who are you? Wide-awake Kutztown University computer science students who want to learn to design and implement data structures and algorithms in C++ at 8:00 AM three days a week! You have already taken CSC 125, CSC 136, Computer Science II, earning >= C. This course extends the topics developed in CSC 135. Also covered are: concepts of data abstraction, encapsulation, recursion; search and sort methods; and simple data structures. (Ah, this is the fine print for CSC 136!)

4. What are we planning to do? We will learn to build the data structures and algorithms that are at the core of substantial software systems. Containers such as lists, tables, stacks, queues, trees Sets and mappings from keys to values Algorithms for sorting or otherwise organizing data Algorithms and file I/O techniques for persistent storage We will use modular construction techniques, with the assistance of C++ abstract classes. We will use the standard template library (STL) for some projects.

5. References First day handout (syllabus) GNU make http://www.gnu.org/software/make/manual/ http://www.gnu.org/software/make/manual/ GDB http://www.gnu.org/software/gdb/documentation/ http://www.gnu.org/software/gdb/documentation/ http://faculty.kutztown.edu/parson

6. An example makefile makefile in ~parson/ DataStructures /lecture1/intro all: build TARGET = printdemo DEBUG = 1 include $(HOME)/makelib build: $(TARGET) $(TARGET): $(OBJFILES) $(CPPCC) $(OBJFILES) -o $@ clean: subclean /bin/rm -f $(TARGET) $(TARGET).out $(TARGET).dif test: $(TARGET)./$(TARGET) a b c d e > $(TARGET).out diff $(TARGET).out $(TARGET).ref > $(TARGET).dif

7. makelib in my $HOME/ makelib CPPCC= g++ CXXFILES := $(wildcard *.cxx) OBJFILES := $(subst.cxx,.o,$(CXXFILES)) DEFFLAGS = ifeq ($(DEBUG),1) DEBUGFLAG = -g else DEBUGFLAG = endif INCFLAGS = -I. CPPFLAGS= $(DEFFLAGS) $(INCFLAGS) $(DEBUGFLAG) %.o : %.cxx $(CPPCC) -c $(CPPFLAGS) $< subclean: /bin/rm -f *.o

8. Some other files in my $HOME/.bash_profile -bash-3.00$ cat.bash_profile export EDITOR=/usr/local/bin/vim export VISUAL=/usr/local/bin/vim alias vi=vim alias make=gmake.vimrc -bash-3.00$ cat.vimrc set ai set ts=4 set sw=4 set expandtab set sta

9. Interface definitions split source along module / driver boundaries. printargs.h defines the interface to its module #ifndef PRINTARGS_H #define PRINTARGS_H #include /* Function: printargs Prints an array of strings to an output file. Parameters: outfile: output file for writing. stringv: array of \0-terminated strings to be printed. stringc: numbers of strings in stringv Return value: none Side Effects: none Preconditions: The outfile must be a non-NULL, open FILE. stringc must equal the number of strings in stringv. Each string in stringv must be terminated with a \0 character. Postconditions: none (no return values from this function). Invariants: none */ void printargs(FILE *outfile, const char **stringv, const int stringc); #endif

10. Implement the interface in a.cxx file. printargs.cxx implements the module of printargs.h /* printargs.cxx -- Function implementations for printargs.h. CSC237, Fall, 2008, Dr. Dale Parson, Class 1 example. This is a simple demo library module that prints an array of strings to an output file. */ #include "printargs.h" void printargs(FILE *outfile, const char **stringv, const int stringc) { int i ; for (i = 0 ; i < stringc ; i++) { fputs(stringv[i], outfile); fputs("\n", outfile); }

11. Invoke the interface from a client module or test driver. printmain.cxx is the test driver /* printmain.cxx -- main function that invokes printargs. CSC237, Fall, 2008, Dr. Dale Parson, Class 1 example. This is a simple driver for a demo library module that prints an array of strings to an output file. */ #include "printargs.h" int main(int argc, const char *argv[]) { printargs(stdout, argv, argc); return 0 ; }

12. Makefile-driven testing makefile is structured for testing -bash-3.00$ make clean test /bin/rm -f *.o /bin/rm -f printdemo printdemo.out printdemo.dif g++ -c -I. -g printargs.cxx g++ -c -I. -g printmain.cxx g++ printargs.o printmain.o -o printdemo./printdemo a b c d e > printdemo.out diff printdemo.out printdemo.ref > printdemo.dif

13. GDB for debugging -bash-3.00$ gdb --args printdemo a b c (gdb) break main Breakpoint 1 at 0x107f4: file printmain.cxx, line 13. (gdb) break printargs Breakpoint 2 at 0x10780: file printargs.cxx, line 14. (gdb) run Starting program: /export/home/faculty/parson/UnixSysProg/lecture1/printdemo a b c Breakpoint 1, main (argc=4, argv=0xffbffc54) at printmain.cxx:13 13printargs(stdout, argv, argc); 14(gdb) p argc 15$1 = 4 16(gdb) p &argc 17$2 = (int *) 0xffbffc34

14. GDB continued (gdb) cont Continuing. Breakpoint 2, printargs (outfile=0x20b20, stringv=0xffbffc54, stringc=4) at printargs.cxx:14 14 for (i = 0 ; i < stringc ; i++) { (gdb) step 15 fputs(stringv[i], outfile); (gdb) next /export/home/faculty/parson/UnixSysProg/lecture1/printdemo 16 fputs("\n", outfile); (gdb) next 14 for (i = 0 ; i < stringc ; i++) { (gdb) p i $3 = 0 (gdb) p &i $4 = (int *) 0xffbffb6c

15. C++ interfaces and implementation classes ~parson/DataStructures/lecture1/oo_variant We will walk through code and test execution in class. C++ abstract classes are used as interfaces. Derived C++ concrete classes provide implementation. Client code, including test drivers, use an interface without coding dependencies on underlying implementation class.

16. Unified Modeling Language (UML) Class Diagram of oo_variant print_main printmain.cxx > printargs_interface.h printargs_interface printargs_interface.cxx printargs(outfile : file, stringv : string[], stringc : int) printargs_simpleimpl printargs_simpleimpl.h printargs_simpleimpl.cxx

17. Programming practices Always check and handle error return codes! malloc() and new are exceptions that we will discuss. Error logs, exit codes and C++ exceptions are useful. Buffer overruns are annoying and dangerous See man page for gets(), for example. Make malloc/free or new/delete symmetrical. Always use { curly braces } for control blocks. Use both healthy and degenerate tests. » Ignoring these rules will cost you points.