Quick review of previous lecture Ch6 Structure Ch7 I/O. EECS2031 Software Tools. C - Structures, Unions, Enums & Typedef (K&R Ch.

Transcription

1 1 Quick review of previous lecture Ch6 Structure Ch7 I/O EECS2031 Software Tools C - Structures, Unions, Enums & Typedef (K&R Ch.6) Structures Basics: Declaration and assignment Structures and functions Pointer to structures Arrays of structures Self-referential structures (e.g., linked list, binary trees) Unions 2

2 2 Structure Names Give a name (tag) to a struct, so we can reuse it: struct shape { float width; float height; }; struct shape is a valid type struct shape chair, chair2; /* int i, j */ struct shape table; shape table; 3 Initialization, operations (. = &) struct shape chair = {2,4}; // approach 1 width height struct shape chair, chair2; chair.width = 2; chair.height = 4; approach 2 struct myshape { chair2 = chair; // copy members values only int data; // different from Java float arr[3]; }; printf( %d %d, chair2.width, chair2.height); struct myshape s2 = {2, {1.5, 2.5}}; //approach 1 chair2.width s2.arr[2] = 3.3; = 20; // // approach does not 2 affect chair 4

3 3 Initialization, operations (. = &) struct shape chair = {2,4}; // approach 1 width struct shape chair2; chair2 = chair; // copy members values only // different from Java 2 2 printf( %d %d, chair.width, chair2.width); printf( %d %d, chair.height,chair2.height); chair2.width = 20; // does not affect chair 4 height 4 printf( %d %d, chair.width, chair2.width); Structures Basics: Declaration and assignment Structures and functions Pointer to structures Arrays of structures Self-referential structures (e.g., linked list, binary trees) Unions 6

4 4 Structure and functions --Structures as arguments You can pass structures as arguments to functions void do_sth(struct shape d) call-by-value { d = str // copy members d.width += 100; d.height += 200; } main() { struct shape str = {1,2}; do_sth(str) /* str is not changed */ } This is call-by-value - a copy of the struct is made 7 Function cannot change the passed struct structure and functions -- Structure Pointers call-by-value is inefficient for large structures: use pointers!!! Using pointers also allows to change the passing struct void do_sth(struct shape * d) { } (*d).width += 100; (*d).height += 200; Expect a pointer to struct shape // Pointee is modified! This is call-by-value but address by reference 8 Function can change the passed struct

5 5 structure and functions -- Structure Pointers void do_sth(struct shape *d){ (*d).width += 100; } Beware when accessing members a structure via its pointer * d.width --- incorrect. has higher precedence than * (*d).width --- correct Accessing member of a structure via its pointer is so common that it has its own operator d -> width 9 structure and functions -- Structure Pointers call-by-value is inefficient for large structures: use pointers!!! This also allows to change the passing struct main(){ struct shape s = {1,3}; struct shape * ptrs = &s; do_sth (ptrs); // or do_sth(&s) } void do_sth(struct shape *d) { d -> width += 100; d -> height += 200; }10 Expect a pointer to struct shape

6 6 Pointer to structures -- malloc/calloc struct shape * ptable; // pointer to struct shape ptable = malloc (sizeof(struct shape)); ptable -> width = 1.0; // ptable -> height = 5.0; // (* ptable).width (* ptable).height or ptable =(struct shape *) malloc (sizeof(struct shape)); 11 Structures vs. Arrays Array: elements of same type Structure: element can be of different type Array: element access by position arr[1] = 3; Structure: element access by name chair.width = 4 Array: cannot assign as a whole arr2 = arr1 Structure: can assign/copy as a whole chair2 = chair1 Array: size is the sum of size of elements Structure: size is not necessarily the sum of size of elements Array: name contains address, pass to function can modify Structure: need & to modify (like scalar variables int, char, float) 12

7 7 Structures Basics: Declaration and assignment Structures and functions Pointer to structures Arrays of structures Self-referential structures (e.g., linked list, binary trees) Unions 13 Arrays of structures Structures can be arrayed same as the other variables struct shape { float width; float height; }; array of 10 struct struct shape chairs[10]; // int arr[10] //chairs[n] is a structure. chairs[2].height = 2; chairs[2].width = 3; struct shape * chairs[10]; 14 // array of 10 struct pointers

8 8 Structures Basics: Declaration and assignment Structures and functions Pointer to structures Arrays of structures Self-referential structures (e.g., Linked list, Binary trees) Unions 15 Self-referential structures Simplest example: a linked list of int s struct node { int data; struct node *next; }; struct node * head; // a pointer to first node

9 9 Self-referential structures struct node * head; int has_value(int dat) { struct node * curr; // a local pointer } /* traverse the list */ curr = head; while (curr!= NULL){ (*curr).data if ( curr -> data == dat ) return 1; // find it! curr = curr -> next; // curr = *(curr).next } return 0; 420 Allocating Structures struct node * head; void insert_begining(int dat) { struct node newnode; newnode.data = dat; newnode.next = head; request heap newnode is in stack! } head = &newnode; 18

10 10 Allocating Structures struct node * head; void insert_begining(int dat) { struct node * newp; newp = malloc(sizeof(struct node)); request space in heap!!! newp -> data = dat; newp -> next = head; // (*newp).data = dat; // (*newp).next = head } head = newp; 19 20

11 11 EECS Software Tools C - Input/Output (K&R Ch. 7) Streams Input and output are sequences of bytes Commonly, abstractly called streams This word is also used in C Pre-defined console streams: opened for you stdin is an input stream stdout is an output stream stderr is an output stream Disk file streams -- by fopen(), fclose() 22

12 12 Streams (more general, more abstractly) When you run program, you get 3 standard streams (pointer to streams) automatically: stdin, stdio, stderr are all of type FILE * declared in <stdio.h> do not try to de-reference these pointers. Don t open / close stdin stdandard input stream, initially keyboard stdout standard output strean, initially screen o both can be redirected using < > stderr standard error, initially the screen o cannot be redirected. We can get diskfile I/O stream with fopen() 23 declared in <stdio.h> Summary FILE *: predefined stdin, stdout, stderr return from fopen( filename, mode ) Formatted I/O Char level I/O Line level I/O Others: 24Direct I/O Standard IO (special) printf() scanf() variants: sprint, sscanf getchar() putchar(int c) gets(char *s) (depreciated) puts(char *) Stream IO (general) fprintf (FILE *, ) fscanf (FILE *, ) fgetc (FILE *) fputc (int c, FILE *) getc (FILE *) putc (int c, FILE *) fgets (char *,int, FILE *) fputs (char *s, FILE *) fread (void*,int, int, FILE*) fwrite(void*,int, int, FILE*)

13 13 Streams -- formatted I/O printf() and scanf() have general variants which operate on any stream including stdin, stderr, and disk file stream: int fprintf(file *f, char *fmt, ); int fscanf (FILE *f, char *fmt, ); so printf() == fprintf(stdout, ) scanf() == fscanf (stdin, ) Exactly same conversion specifications as printf(), scanf() fprintf(stdout, %d %c %s, a, b, arr); fscanf (stdin, %d %c %s, &a,&b, arr); 25 Streams I/O character level There are general versions of getchar() and putchar(): int getc(file *); int putc(int c, FILE *); The following functions are also defined (historical reason): int fgetc(file *); int fputc(int c, FILE *); They are similar to getc() and putc() getchar() == getc(stdin) == fgetc(stdin) putchar(c)== putc(c,stdout)== fputc(c,stdout) 26All behave the same at end of file: return EOF

14 14 Streams I/O Line level I/O A function for dealing with lines: char *fgets(char *s,int n, FILE *f) more general (and safer) version of gets() reads in a line from f and stores it in s until (n-1) characters are read, or until a newline character is read ( \n ) if \n is read, it is also stored in the string int fputs( char *s, File * f ) more general version of puts() gets(s) == fgets(s, n, stdin) // return null pointer at EOF puts(s) == fputs(s, stdout) 27 Disk file stream FILE *: predefined stdin, stdout, stderr return from fopen( filename, mode ) We are not restricted to just stdin, stdout and stderr FILE * fopen(char *filename, char *mode); creates a new stream by opening a file called filename if it fails (file does not exists, wrong path, no permission ), returns NULL When we are done with a file, we can get rid of the stream with: int fclose(file *f); returns 0 on success, EOF on failure 28 Note: When a program exits all open files are automatically closed

15 15 FILE * fopen(char *filename, char *mode); Stream Modes mode tells us whether we are reading or writing (it s a string) r -- read-only fopen( input.txt, r ); file must exist w -- write-only file is created if necessary, contents are destroyed on open a -- append (write-only) file is created if necessary, contents preserved (write at the end of the file) 29 FILE * fopen(char *filename, char *mode); Stream Modes There are also update modes: r+ -- like r but we can also write w+ -- like w but we can also read a+ -- like a but we can also read Some systems (not Unix) distinguish between text and binary files Default is to open in text mode Add b for binary mode (e.g. rb ) 30

16 16 Stream Direct IO (Block I/O Binary I/O ) Streams are made up of bytes They may not be text: int fread(void *ptr, int size, int n, FILE *f); Reads from file pointed by f, n elements, each size bytes long and puts them at the address specified by ptr read from f n*size bytes, write to ptr e.g. to read n bytes fread(ptr,1,n,f); 31 Stream -- direct IO (Binary I/O) There is a corresponding function for writing out binary data int fwrite(void *ptr, int size, int n, FILE *f); Write to file pointed by f, n elements, each size bytes long, from the address specified by ptr read from ptr n*size bytes, write to f 32

17 17 Stream -- Direct IO (Binary I/O, Block I/O) // Example. Read / Write arrays to / from file FILE * in, out; in = fopen( in.txt, r ); out = fopen( out.txt, w ); int arr[] = {1,2,3,4,5}; fwrite(arr, sizeof(int), 5,out); // write array to file fwrite(arr, sizeof(arr), 1,out); // write array to file int arr2[5]; fread(arr2, sizeof(int), 5, in); //read file, write to arr2 fread(arr2, sizeof(arr), 1, in); //read file, write to arr2 Read/write array of stucts, array of pointers etc.. 33 Other stream I/O functions More: fseek() ftell() rewind() remove() rename() fflush() Explore by yourself 34

18 18 Other topics that we did not get to cover -- might be useful in your future studies const Union, enum, typedef Pointer to functions System calls (fork, pipe read, write) -- K&R Ch 8 You will see if you take CSE3221 operating systems. Others Make file make That is all for C for this course Now we have to start a new book, a new programming language.. Let s do it! 36