ECE160 - Lesson 4
Tic-Tac-Toe, More about Functions, Program Structure, Make files
Professor Hong
## Review & Questions
## Quiz #1 * Closed book * 20 minutes
## Make Files - atof
## atof - in 1 file ``` #include <stdio.h> #include <ctype.h> // K&R Pg. 71 // atof: convert string s to double double atof(char s[]) { double val, power; int i, sign; for (i=0; isspace(s[i]); i++) // skip white space ; sign = (s[i] == '-') ? -1 : 1; if (s[i] == '+' || s[i] == '-') i++; for (val=0.0; isdigit(s[i]); i++) val = 10.0 * val + (s[i] - '0'); if (s[i] == '.') i++; for (power=1.0; isdigit(s[i]); i++) { val = 10.0 * val + (s[i] - '0'); power *= 10.0; } return sign * val / power; } int main() { char input[] = "-1.23"; printf("%f\n", atof(input)); return 0; } ```
## atof - in 2 files - atof.c and atof.h ``` #include <stdio.h> double atof(char s[]); ``` ``` #include <ctype.h> // K&R Pg. 71 // atof: convert string s to double double atof(char s[]) { double val, power; int i, sign; for (i=0; isspace(s[i]); i++) // skip white space ; sign = (s[i] == '-') ? -1 : 1; if (s[i] == '+' || s[i] == '-') i++; for (val=0.0; isdigit(s[i]); i++) val = 10.0 * val + (s[i] - '0'); if (s[i] == '.') i++; for (power=1.0; isdigit(s[i]); i++) { val = 10.0 * val + (s[i] - '0'); power *= 10.0; } return sign * val / power; } ```
## atof - in 2 files - main.c ``` #include <stdio.h> #include <atof.h> int main() { char input[] = "-1.23"; printf("%f\n", atof(input)); return 0; } ```
## atof - in 2 files - compiling ``` gcc -o main atof.c main.c -I. ```
## Simple Make File ``` # this will compile all files everytime make is run make: main.c atof.c atof.h gcc -o main main.c atof.c -I. # this will clean or remove compiled files so you can start fresh clean: rm -f *.o *.exe ``` * <code>make</code> * <code>make clean</code>
## Updated Make File ``` # Definitions for constants CC=gcc CFLAGS=-I. # This will create your final output using .o compiled files make: main.o atof.o $(CC) $(CFLAGS) -o main main.o atof.o # This will compile atof.c atof.o: atof.c atof.h $(CC) $(CFLAGS) -c atof.c # This will compile main.c with its dependency main.o: main.c atof.h $(CC) $(CFLAGS) -c main.c # This will clean or remove compiled files so you can start fresh clean: rm -f *.o *.exe ``` * This allows you to only recompile
## Make Files - Reverse Polish Calculator
## Calculator - All in 1 File ``` #include <stdio.h> #include <stdlib.h> // for atof() // K&R page 76-79 #define MAXOP 100 // max size of operand or operator #define NUMBER '0' // signal that a number was found int getop(char []); void push(double); double pop(void); // reverse Polish calculator int main() { int type; double op2; char s[MAXOP]; while ((type = getop(s)) != EOF) { switch (type) { case NUMBER: push(atof(s)); break; case '+': push(pop() + pop()); break; case '*': push(pop() * pop()); break; case '-': op2 = pop(); push(pop() - op2); break; case '/': op2 = pop(); if (op2 != 0.0) push(pop() / op2); else printf("error:zero divisor\n"); break; case '\n': printf("\t%.8g\n", pop()); break; default: printf("error: unknown command %s\n", s); break; } } return 0; } #define MAXVAL 100 // maximum depth of val stack int sp = 0; // next free stack position double val[MAXVAL]; // value stack // push: push f onto value stack void push(double f) { if (sp < MAXVAL) val[sp++] = f; else printf("error:stack full, can't push %g\n", f); } // pop:pop and return top value from stack double pop(void) { if (sp > 0) return val[--sp]; else { printf("error:stack empty\n"); return 0.0; } } int getch(void); void ungetch(int); // getop: get next operator or numeric operand int getop(char s[]) { int i, c; while ((s[0] = c = getch()) == ' ' || c == '\t') ; s[1] = '\0'; if (!isdigit(c) && c != '.') return c; // not a number i = 0; if (isdigit(c)) // collect integer part while (isdigit(s[++i] = c = getch())) ; if (c == '.') // collect fraction part while (isdigit(s[++i] = c = getch())) ; s[i] = '\0'; if (c != EOF) ungetch(c); return NUMBER; } #define BUFSIZE 100 char buf[BUFSIZE]; // buffer for ungetch int bufp = 0; // next free position in buf int getch(void) // get a (possibly pushed back) charater { return (bufp > 0) ? buf[--bufp] : getchar(); } void ungetch(int c) // push character back on input { if (bufp >= BUFSIZE) printf("ungetch:too many characters\n"); else buf[bufp++] = c; } ```
## Calculator in Multiple Files - main.c ``` #include <stdio.h> #include <stdlib.h> #include <calc.h> // K&R page 76-79 #define MAXOP 100 // max size of operand or operator // reverse Polish calculator int main() { int type; double op2; char s[MAXOP]; while ((type = getop(s)) != EOF) { switch (type) { case NUMBER: push(atof(s)); break; case '+': push(pop() + pop()); break; case '*': push(pop() * pop()); break; case '-': op2 = pop(); push(pop() - op2); break; case '/': op2 = pop(); if (op2 != 0.0) push(pop() / op2); else printf("error:zero divisor\n"); break; case '\n': printf("\t%.8g\n", pop()); break; default: printf("error: unknown command %s\n", s); break; } } return 0; } ```
## Calculator in Multiple Files - calc.h ``` #define NUMBER '0' // signal that a number was found void push(double); double pop(void); int getop(char []); int getch(void); void ungetch(int); ```
## Calculator in Multiple Files - stack.c ``` #include <stdio.h> #include <calc.h> #define MAXVAL 100 // maximum depth of val stack int sp = 0; // next free stack position double val[MAXVAL]; // value stack // push: push f onto value stack void push(double f) { if (sp < MAXVAL) val[sp++] = f; else printf("error:stack full, can't push %g\n", f); } // pop:pop and return top value from stack double pop(void) { if (sp > 0) return val[--sp]; else { printf("error:stack empty\n"); return 0.0; } } ```
## Calculator in Multiple Files - getop.c ``` #include <stdio.h> #include <ctype.h> #include <calc.h> // getop: get next operator or numeric operand int getop(char s[]) { int i, c; while ((s[0] = c = getch()) == ' ' || c == '\t') ; s[1] = '\0'; if (!isdigit(c) && c != '.') return c; // not a number i = 0; if (isdigit(c)) // collect integer part while (isdigit(s[++i] = c = getch())) ; if (c == '.') // collect fraction part while (isdigit(s[++i] = c = getch())) ; s[i] = '\0'; if (c != EOF) ungetch(c); return NUMBER; } ```
## Calculator in Multiple Files - getch.c ``` #include <stdio.h> #include <ctype.h> #include <calc.h> // getop: get next operator or numeric operand int getop(char s[]) { int i, c; while ((s[0] = c = getch()) == ' ' || c == '\t') ; s[1] = '\0'; if (!isdigit(c) && c != '.') return c; // not a number i = 0; if (isdigit(c)) // collect integer part while (isdigit(s[++i] = c = getch())) ; if (c == '.') // collect fraction part while (isdigit(s[++i] = c = getch())) ; s[i] = '\0'; if (c != EOF) ungetch(c); return NUMBER; } ```
## Calculator - Compiling ``` gcc -o main.exe main.c getch.c getop.c stack.c -I. ```
## Calculator - Make File ``` # Definitions for constants CC=gcc CFLAGS=-I. # This will create your final output using .o compiled files make: main.o stack.o getch.o getop.o $(CC) $(CFLAGS) -o main main.o stack.o getch.o getop.o stack.o: stack.c $(CC) $(CFLAGS) -c stack.c getch.o: getch.c $(CC) $(CFLAGS) -c getch.c getop.o: getop.c $(CC) $(CFLAGS) -c getop.c # This will compile main.c with its dependency main.o: main.c calc.h $(CC) $(CFLAGS) -c main.c # This will clean or remove compiled files so you can start fresh clean: rm -f *.o *.exe ```
## The C Preprocessor
## File Inclusion * <code>#include "filename.h"</code> - includes file in directory of where the source program was found; else follows an implementation defined rule. * <code>#include <filename.h></code> - follows an implementation-defined rule to find the file * We specify the directories inside the makefile with the -I. flag
## Macro Substitution * <code>#define name replacement text</code> - can also be used to substitute macros * Be careful as it literally just replaces a name with the replacement text. * Be careful with your order of operations.
## Conditional Inclusions ``` #if !defined(HDR) #define HDR /* contents of hdr.h go here */ #endif ``` * Useful for not including code you've already included when compiling.
## More About Functions & Program Structure
## Recursion - printd * Have a function call itself over and over again (until a condition breaks) ``` #include <stdio.h> // K&R pg. 87 // printd:print n in decimal void printd(int n) { if (n < 0) { putchar('-'); n = -n; } if (n / 10) printd(n / 10); putchar(n % 10 + '0'); } int main() { printd(-987654321); return 0; } ```
## Recursion - quick sort * You will be learning more about sorts in DSA I. ``` #include <stdio.h> // K&R pg. 88 // swap:interchange v[i] and v[j] void swap(int v[], int i, int j) { int temp; temp = v[i]; v[i] = v[j]; v[j] = temp; } // K&R pg. 87 // qsort:sort v[left]...v[right] into inreasing order void qsort(int v[], int left, int right) { for (int i=0; i<3; i++) printf("%d ", v[i]); printf("; left=%d, right=%d\n",left,right); int i, last; if (left >= right) // do nothing if array contains fewer than two elements return; swap(v, left, (left + right)/2); // move partition elem to v[0] last = left; for (i = left+1; i <= right; i++) // partition if (v[i] < v[left]) swap(v, ++last, i); swap(v, left, last); qsort(v, left, last-1); qsort(v, last+1, right); } int main() { int v[] = {3, 1, 2}; int left = 0; int right = 2; printf("ORIGINAL: "); for (int i=0; i<3; i++) printf("%d ", v[i]); printf("\n"); qsort(v, left, right); printf("SORTED: "); for (int i=0; i<3; i++) printf("%d ", v[i]); return 0; } ```
## External/Global Variables * Declared outside of functions * Can be accessed by any function if the name has been declared * We used it to keep track of the tic-tac-toe board & the letter for the computer and the user * A better practice is to create a struct (or a class in C++) to keep track of the board * We will do another example later. * Too many global variables can be dangerous!
## Scope Rules * Local Variable in a function - the point of the declaration to the end ofthe function * Variables in different functions with the same variable names are unrelated * Global Variable - the point at which it is declared to the end of the file being compiled * <code>extern</code> - is needed to access a variable before it is defined or is in a different source file * declares that this variable is available for use for the rest of the file
## Block Structure * Variables in a "block structure" ``` #include <stdio.h> int x = 10; int y = 11; void function(double x) { double y = 100; printf("Inside function: x=%f, y=%f\n", x, y); } int main() { int i = 1; int n = 1; printf("i before if: %d\n", i); if (n > 0) { int i = 777; // declare a new i printf("i in if: %d\n", i); } printf("i after if: %d\n", i); printf("Before function: x=%d, y=%d\n", x, y); function(200); printf("After function: x=%d, y=%d\n", x, y); return 0; } ``` * Note that the types can even be different! * DON'T DO THIS!! IT'S VERY HARD TO DEBUG!
## Register Variables & Initialization * <code>register</code> - can be used before a normal declaration to store the variable in the machine register * Can result in smaller and faster programs. * Hardware dependent * We've been using initialization already; it's just shorthand for declaring and setting a varriable * Default is 0 or possibly garbage in the register * <code>int x = 1;</code>