C Programming Day 4 based upon Practical C

C Programming Day 4 based upon Practical C Programming by Steve Oualline CS 550 Operating Systems

Tic Tac Toe Example • See class website – http: //catpages. nwmissouri. edu/m/monismi/cs 550/ examples. html • Compilation gcc Tic. Tac. Toe. c tttmain. c -ansi -o ttt. exe

Tic Tac Toe Makefile • Using a makefile for compilation – use make to compile • Makefiles are similar to a script to compile programs • We break many of our programs into groups of files – header files with function prototypes (. h files) –. c files with function definitions – file or files containing main function(s)

Example Makefile • Example with one. c file CC=gcc CFLAGS=-ansi prog 3 : prog 3. c $(CC) $(CFLAGS) -o prog 3. c #There must be a tab on the line following prog 3 #(the target) #Comments are preceded with a pound sign/hash #symbol (#)

More on Makefiles • If you name your makefile "makefile", then to compile you simply type the command make. • Otherwise, you need to specify the name of your makefile as follows: make -f my_makefile_name

Tic Tac Toe Makefile CC=gcc CFLAGS=-ansi #executable first, then sources ttt: Tic. Tac. Toe. o tttmain. o $(CC) $(CFLAGS) -o ttt Tic. Tac. Toe. o tttmain. o: Tic. Tac. Toe. h tttmain. c $(CC) $(CFLAGS) -c tttmain. c Tic. Tac. Toe. o: Tic. Tac. Toe. h Tic. Tac. Toe. c $(CC) $(CFLAGS) -c Tic. Tac. Toe. c

More on functions • • • void functions with parameters return types call by value call by reference

Call by value int min(int a, int b) { if(a < b) return a; return b; } The values of a and b are copied from those of the formal parameters.

Call by Reference Example for Arrays #include <stdio. h> //pass in the address of the array int length(char[]); //Call by reference void change. Char(char [], int, char); //Call by value void change. Int(int, int);

Example main Function int main(int argc, char ** argv){ char line[100]; while(1) { fgets(line, sizeof(line), stdin); //Read a line[strlen(line) - 1] = ''; //Remove 'n' printf("The length of this string is %dn", length(line)); change. Char(line, 2, 'x'); //Call the function printf("%sn", line); //Print the modified string int q = 5; change. Int(q, 2); //What happens with call by value? printf("The value of q is %dn", q); } }

Functions for Example int length(char str[]){ int i; for(i = 0; str[i] != ''; i++); return i; } //Call by Reference void change. Char(char str[], int pos, char new_char){ str[pos] = new_char; } //Call by value void change. Int(int z, int y) { z = y; }

Recursion • Same as in Java • We won’t review this • Use as necessary

Macros • #define lets you define a macro • #define works as a global text editor in your program

Macro Examples #define PI 3. 14 #define ENDIF } if(x == y) {. . . ENDIF

Macro Examples #define IF if( #define THEN ){ IF x == y THEN. . . ENDIF #define SQR(x) ((x)*(x)) //Safe macro SQR(5 + 7) #define SQR(x) (x*x) //Unsafe macro

Character Macros • Character macros are in #include <ctype. h> • includes things like is_digit(x) • The text of the macros below is inserted in your code in place of the name of the macro. #define is_lower(x) ((x) >= 97 && (x) <= 122) #define SWAP(x, y) { //continue to next line char temp; temp = (x); (x) = (y); (y) = temp; }

Structures • Structures are used to group data together struct Student { char f. Name[100]; char l. Name[100]; int num 919; char classification[30]; } s 1, s 2; //Create a struct of type //struct student and two structures

Structures struct Student s 3; //Create another struct Student typedef struct Student; //Rename struct Student as Student s 4; //Create another student typedef double mydouble; strcpy(s 4. classification, "Freshman"); s 4. num 919 = 919000000; s 3. num 919 = 23; Student slist[100]; slist[53]. num 919 = 919111111;

More on Structures • Generically, a structure appears as follows: struct_type_name { variable_list } names_for_structs; • both the type name and names are optional. • More examples: struct student { char f. Name[100]; char l. Name[100]; int num 919; };

More on Structures typedef struct student; int main(int argc, char ** argv){ student s. Arr[5]; strcpy(s. Arr[0]. f. Name, "David"); strcpy(s. Arr[1]. f. Name, "John"); . . . }

More on typedef old_type new_type; //Redefine an old type as a //new one. typedef double dollars; dollars wallet; double a; wallet = 100. 0; wallet = wallet + 5; a = 10; wallet = a + wallet; a = 3/4; //a is assigned 0 a = (double) 3 / 4; //a is assigned 0. 75 //Recall types are upcast double <-- int <-- char

<time. h> time_t is an unsigned int time(0) returns a value of type time_t int a; a = time(0) + 5; //Casting down time(0) is cast as an int, and will cause a compiler warning in most cases. a = (int) time(0) + 5; //avoids the warning

Pointers • Pointers allow you to store and manipulate memory addresses. • Pointers are fun!!! • Pointers are used for arrays int arr[5]; //arr contains the memory address of //the beginning of the array arr • Pointers are also seen in a different form: type * name; //"type *" indicates the address of a type • This can also be read as a pointer to memory type "type".

Super Important Example int * p; //A pointer to an integer p = NULL; //NULL is in <stdlib. h> and is //of int value zero or '’ int a = 7; p = &a; //The ampersand means "address of", so //p is assigned the address of a. printf("%d is an", a); printf("%d is an", *p); //get the value stored //at the address in p • • The * is the dereferencing operator Dereferencing NULL will result in a segmentation fault. You cannot access memory address 0.

Pointers • Pointers allow for call by reference and dynamic memory allocation • Use of the dereferencing operator (the * operator) to access the contents of a pointer int a = 8; int * b = &a; //Store the address of a in b printf("a is %dn", a); printf("a is %dn", *b);

Pointers • You can try to print the contents of a static address, but it won't always work because most operating systems protect their memory. printf(”Contents of address 190 are %dn", *((int *) 190) ); //This will work, though because memory //addresses are unsigned ints printf("%u is bn", b); printf("%u is also bn", &a);

Constant Pointers • Notice that you can't change the value of a constant. const int result = 10; result = 5; // causes an error const char * str_ptr = "Forty-nine"; const char arr[28] = "Eighty-2"; str_ptr = arr; //This is ok because the data is constant str_ptr[7] = 'B'; //Not ok because the data is constant char * const name_ptr = "Test pointer"; name_ptr = str_ptr; //Won't work b/c the pointer is constant name_ptr[7] = 'b'; //will work b/c the pointer is constant

Call by Reference • In C there is no real call by reference. • It is simulated by passing the values of addresses to functions, that is, by passing pointers.

Call by Reference Example void swap(int * a, int * b){ //This swaps two variables int temp; temp = *a; //Dereference the address stored in a *a = *b; *b = temp; } int main(int argc, char ** argv){ int x, y; x = 5; y = 9; printf("x is %d and y is %dn", x, y); swap(&x, &y); printf("x is %d and y is %dn", x, y); return 0; }

Scope Rules • The scope of an identifier (a variable) is the part of the program where the variable is accessible. • Normally, the basic rule for scope is that variables are only accessible within the block (set of curly brackets) in which they were declared. • Notice that variables declared in an inner block with the same name as those in an outer block take precedence within the inner block.

Scope Example int main(int argc, char ** argv){ int a = 2; int * p = a; printf("%d is an"); { int a = 7; //This a is different printf("%d is an", a); printf("%d is a from the outer blockn", *p); } printf("%d is an"); return 0; }

Void Pointers • A void pointer can point to any type of memory. • These are essential for dynamic memory allocation. void * name;

Void Pointer Example int main(int argc, char ** argv){ int * p, * q, r; double * x; void * a; r = 1000; p = q = (int *) r; a = (void *) r; p = q = a; x = a; return 0; }

Pointers and Arrays int arr[6] = {1, 2, 3, 4, 5, 6}; *(arr + 2) = 56; //Notice 2 is multiplied by //sizeof(int) What really happens is that we get *(arr + 2*sizeof(int)) the compiler takes care of the sizeof operation for us.

Example Part 1 • Loops used to sum up the values of an array using dereferencing instead of brackets. *arr --> arr[0] *(arr+1) --> arr[1]. . . int sum = 0, i; for(i = 0; i < N; i++) sum += *(arr + i);

Example Part 2 //is the same as for(i = 0; i < N; i++) sum += arr[i]; int arr[N] = {. . . }; int * p; int sum = 0; for(p = arr; p < &arr[N]; p++) sum += *p

Dynamic Memory Allocation • In Java & C++, new is used for dynamic memory allocation. • You can use delete in C++ to free dynamic memory. • In C, we will use malloc and calloc for allocation and free for deallocation malloc(sizeof(type)) //Specify the amount of memory calloc(n, object size) //Specify the number of items and type size free((void *) name_of_pointer) //Free memory and cast as void ptr

Examples int *a, n; scanf("%d", &n); //Read an into n if(n > 0) //Allocate an array of size n a = (int *) calloc(n, sizeof(int)); else { //print error and exit printf("Error: invalid array size. n"); exit(0); } a[0] = 32; . . . free((void *) a); //Deallocate a

Card Example struct card { char suit; //one byte int face_value; //four bytes }; typedef struct card; card * deck;

Card Example Continued int main(int argc, char ** argv) { int size; scanf("%d", &size); if(size > 0) deck = (card *) calloc(size, sizeof(card)); //size of card is 5 deck[i]. suit = 'd'; //d for diamonds deck[i]. face_value = 12; //12 th card (king if zero based) free((void *) deck); }

malloc, memset, and memcpy • Using malloc to allocate variables one at a time int * p; //Declare pointers p and q int * q; //Allocate an int array and store its address in p p = (int *) malloc(sizeof(int)); *p = 98; //Store 98 at memory location p free((void *) p); //Free (deallocate) the array

malloc, memset, and memcpy //allocate an array of size n to p with malloc p = (int *) malloc(sizeof(int)*n); q = (int *) malloc(sizeof(int)*n); //Set all elements of p to zero memset(p, 0, sizeof(int)*n); //make a copy of p in q using //memcpy(dest, source, number of bytes to //copy) memcpy(q, p, sizeof(int)*n); free((void *) p); free((void *) q);

Allocating Multi-Dimensional Arrays //Declare a 2 D array int ** md. Arr; int i; int j; //Allocate dimension 1 md. Arr = (int **) calloc(2, sizeof(int *)); for(i = 0; i < 2; i++) //Dim 2 md. Arr[i] = (int *) calloc(3, sizeof(int));

Allocating Multi-Dimensional Arrays //Initialize for(i = 0; i < 2; i++) for(j = 0; j < 3; j++) md. Arr[i][j] = j; //Deallocate for(i = 0; i < 2; i++) free((void *) md. Arr[i]); free((void *) md. Arr);

Linked Lists struct element { int data; //Data struct element * next; //Next pointer }; typedef struct element;

Linked Lists int main(int argc, char ** argv) { element * head; element * cur_ptr; int val; head = NULL; //Pointer to list scanf("%d", &val);

Linked Lists while(val != -999) { if(head == NULL) { /* list is empty */ head = (element *) malloc(sizeof(element)); (*head). data = val; // or use // head->data = val; head->next = NULL; cur_ptr = head; }

Linked Lists else { cur_ptr->next = (element *) malloc(sizeof(element)); cur_ptr->next->data = val; cur_ptr->next = NULL; cur_ptr=cur_ptr->next; } //use scanf to read another value } }

Add an element • Add an element to the beginning of the list ptr->next = head; head=ptr; • Add an element to the middle of the list • If using only one pointer temp->next = prev->next; prev->next = temp; • If using two temp->next = current; prev->next = temp;

Searching in arrays int arr[5] = {7, 8, 1, 4, 3}; int ele, i; int flag = 0; scanf("%d", ele); for(i = 0; i < 5; i++) if(arr[i] == ele) { printf("%d was found at position %dn", arr[i], i); flag = 1; break; } //after loop if(!flag) printf("Value %d not foundn", ele); • Recall that worst case search time is a multiple of the array size

Linked List Searching element * temp; int flag = 0; for(temp = head; temp != NULL; temp = temp->next){ if(temp->data == value) { printf("%d was foundn", value); flag = 1; break; } } if(!flag) printf("Not foundn");

File I/O • In linux we can use redirection for file input or output prog 1. exe < p 1. in prog 1. exe > p 1. out prog 1. exe < p 1. in > p 1. out • In stdio. h there is a struct called FILE and 3 pointers stdin stdout stderr standard input standard output standard error

File I/O • Recall that we have used fgets(str, sizeof(str), stdin) for input • To open a file for writing, we use FILE * ofp; ofp = fopen("filename", "w"); //"w" is for write. . . //do work fclose(ofp);

Writing to a File • Recall that we have used fgets(str, sizeof(str), stdin) for input • To open a file for writing, we use FILE * ofp; ofp = fopen("filename", "w"); //"w" is for write. . . //do work fclose(ofp);

Writing to a file • use fprintf to write to a file fprintf(file_ptr, "Text %d %s", an_int, a_string); • use fscanf or fgets for file input (read from a file) FILE * ifp; ifp = fopen("filename", "r"); //Read from an existing file • fopen returns NULL if the file cannot be read from or found fscanf(ifp, "%d %d", &a, &b); fgets(str, sizeof(str), file_ptr); //For a line of file input

File Position Indicator • fseek(. . . ), ftell(. . . ) • ftell(file_ptr) tells the position of the file pointer in bytes • fseek(file_ptr, offset, place) goes to a position from place – 0 - beginning of the file – 1 -current position in the file – 2 - end of the file

Example FILE * fptr; int filesize; fptr = fopen("filename", "r"); fseek(fptr, 0, 2); filesize = ftell(fptr); //go back to the beginning of the file fseek(fptr, 0, 0);

Reading and Writing Binary • "rb" - read binary • "wb" - write binary • Append to a file – "a" – append – "ab" - append binary

Example FILE * ifp; //Input file pointer FILE * ofp; //Output file pointer int val; int sum = 0; ifp = fopen("input_name", "r"); //Open to read ofp = fopen("output_name", "w"); //Open to write //Read until there is no more input while(fscanf(ifp, "%d", &val) == 1) { fprintf(ofp, "%d", val); //Store result in //output file sum += val; } fprintf(ofp, "n sum %d", sum);

Error Checking if(ifp == NULL) { printf("input file not foundn"); printf("Exiting. . . n"); exit(0); }