1 / 56

System Programming in C

System Programming in C. Lecture 9. Lecture Summary. More language features: Libraries Recursion Unions time.h Continue on dynamic structures Queue. Libraries. Suppose there’s a need to create some “library” that will export some functions and variables.

gizi
Download Presentation

System Programming in C

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. System Programming in C Lecture 9

  2. Lecture Summary • More language features: • Libraries • Recursion • Unions • time.h • Continue on dynamic structures • Queue

  3. Libraries • Suppose there’s a need to create some “library” that will export some functions and variables. • For instance, you’ve written a set of functions for working with linked lists, and want to use them “as is” – i.e. without further modifications and possibly from several places.

  4. Libraries • Possible ways of making code available for use: • Just copy-and pasted the code • Copy-and-Paste the functions • Share source and header file with functions • Make a library – share its interface (as an .H file) and the compiled library.

  5. Libraries • Each further way (in a row 1-4) imposes more initial work, but better insulation between the utility code (in our example - set of functions for working with lists) and its user. • Why insulate library from its user? • Make the library user more independent of the library contents

  6. Libraries • When creating a library, all the functions and variables defined at global scope can be made visible for library user. • Functions and variables defined at the scope other than global are not visible to library user. • Library is just a collection of functions, so presence of main() function in library is not necessary.

  7. Creating a Library – Start with File->New

  8. Creating a library

  9. Creating a library

  10. Once the library is created, add files to it

  11. func1.h /* define the external interface for LIBRARY.LIB - all the functions from the library that will be called from outside the library, should be declared (not defined!) here */ #ifndef FUNC1_H /* to prevent multiple inclusion */ #define FUNC1_H /* here come definitions of external functions, variables, etc. - everything we want to make available to library user. In our case, it is a single function */ func1(); extern int a_variable; #endif /* FUNC1_H */

  12. func1.c #include <stdio.h> /* define a variable in global scope - this variable may be made visible (by declaring it) to library users */ int a_variable = 0; /* define a function in global scope - this function may be made visible (by declaring it) to library users */ func1() { printf("func1 is called\n"); } /* everything that is declared not in global scope is NOT visible from outside of the program - for instance, following variable and functions declared at file scope cannot be made visible to library users and even other source files in the library */ static int intern_variable = 0; static int intern_function() {return 0;}

  13. Libraries – modify project settings

  14. Libraries • At that moment, the library can be built. When library is built, LIBRARY.LIB is placed into the project directory (in our case - C:\WORK\LECT9\).

  15. Using a library • From now on, every project may use the library – to do it, two files are needed: • FUNC1.H - functions prototypes • LIBRARY.LIB - actual code • Let’s create a project that does it

  16. Creating a Library Driver (user) – Start with File->New

  17. Creating a library driver

  18. Creating a library driver

  19. Add a File to Library Driver

  20. main.c /* a simple driver program for LIBRARY.LIB - uses a function from it*/ #include "func1.h" /* include definition of a function from LIBRARY.LIB*/ #include <stdio.h> main() { /* call a function exported by a LIBRARY.LIB */ func1(); /* use an external variable from LIBRARY.LIB */ printf("a_variable from LIBRARY.LIB is equal %d\n", a_variable ); }

  21. Project Settings fixup – Project->Settings...

  22. Set Dependencies - From Project->Dependencies…

  23. Project Settings fixup – Project->Settings...

  24. Program Output

  25. Recursion • Recursive function – either directly or indirectly calling itself • Serves as a tool to solve algorithms by reducing the original problem to a smaller problems (and, in turn, reducing them to a smaller problems.

  26. Recursion Example: /* use of recursion for calcularing the factorial: n! = n * (n-1) * (n-2) * ... * 3 * 2 * 1 */ int func1(int n) /* assumes n>=0 */ { if (!n) return 1; return ( n * func1 ( n-1 ) ); /* recursive call*/ }

  27. Recursion /* use of recursion for reversing the user input */ void func2(void) /* assumes user input */ { int c; if ((c = getchar()) != '\n') func2(); /* recursive call */ putchar(c); }

  28. Example – Tower of Hanoi • The Towers of Hanoi: Given 3 poles, with disks of different sizes numbered 1..n according to size. • Begin: all disks are stacked on pole A with disk 1 on the top and disk n at bottom. • End: all disks are stacked on pole C in the same order • Cannot place disk N on the top of disks 1, 2, ..., N-1

  29. Example – Tower of Hanoi Move disk 1 from A to C Move disk 2 from A to B Move disk 1 from C to B Move disk 3 from A to C Move disk 1 from B to A Move disk 2 from B to C Move disk 1 from A to C => 7 moves for N=3 (..15, 31, 63)

  30. Example – Tower of Hanoi • In general: • Move n-1 disks from A to B through C • Move disk n from A to C • Move n-1 disks from B to C through A

  31. Example – Tower of Hanoi void hanoi (int n, char *a, char *b, char *c) { if (n==1) { printf("Move disk 1 from %s to %s\n", a, c); return; } hanoi(n-1, a, c, b); printf("Move disk %d from %s to %s\n", n, a, c); hanoi(n-1, b, a, c); }

  32. Example – Linked List /* conversion function */ ListItem *array_to_list(int *a, int size) { ListItem *head; if (!size) return NULL; head = (ListItem*)malloc(sizeof(ListItem)); head->data = a[0]; if ( size > 1 ) head->next = array_to_list(a+1, size-1); else head->next = NULL; return head; }

  33. Example – Linked List Definition of ListItem: struct listitem { int data; struct listitem *next; }; typedef struct listitem ListItem;

  34. Unions • Unions are used as variables, when it’s convenient to have the same variable hold different types of data • In effect a union is a struct, in which all members have offset zero. The union is big enough to hold the largest member. • It holds one member at a time

  35. Unions union int_or_float { int iVal; float fVal; }; union int_or_float x; x.iVal = 10; /* x as int */ x.fVal = 4.321; /* x as float, overwrites int */

  36. Unions struct typed_value { enum { INT, FLOAT} type; union int_or_float value; }; struct typed_value aValue; /* aValue hold information on its type*/ aValue.type = INT; aValue.value.iVal = 10;

  37. Unions struct typed_value divide (int a, int b) { struct typed_value answer; if (! (a % b) ) { answer.type = INT; answer.value.iVal = a/b; }else { answer.type = FLOAT; answer.value.fVal = (float)a/(float)b; } return answer; } ... aValue = divide (8,4); aValue = divide (2,3);

  38. time.h • Header file defining structures, macros and functions for manipulating date and time • Usefule for timing your program

  39. time.h typedef long time_t; /* time value */ typedef long clock_t; struct tm { int tm_sec; /* seconds after the minute - [0,59] */ int tm_min; /* minutes after the hour - [0,59] */ int tm_hour; /* hours since midnight - [0,23] */ int tm_mday; /* day of the month - [1,31] */ int tm_mon; /* months since January - [0,11] */ int tm_year; /* years since 1900 */ int tm_wday; /* days since Sunday - [0,6] */ int tm_yday; /* days since January 1 - [0,365] */ int tm_isdst; /* daylight savings time flag */ };

  40. time.h • clock_t clock(void); • returns number of CPU clock ticks since the beginning of execution. Use clock()/CLOCK_PER_SECOND to convert to seconds • to measure time spent in program, call clock() at start of the program, and its return value should be substracted from subsequent calls • time_t time(time_t *tptr); returns current calendar time (number of seconds elapsed since midnight (00:00:00), January 1, 1970, coordinated universal time, according to the system clock.).

  41. time.h • char *asctime(const struct tm *tp); • converts tm to a string, for printing • char *ctime(time_t *tptr); • converts time_t tptr to a string, for printing • double difftime(time_t t0, time_t t1); • returns t1-t0 • Use two calls for time and then difftime to compute how long your program runs.

  42. Linked Lists - Queue

  43. Adding Element to Queue

  44. Getting Element from Queue

  45. Queue: Principles of Operations • Queue is quite similar to stack. • Possible to implement in linked list and array – will discuss both ways • Just an ordered list with two ends – possible operations are: inserting element to the first end and getting/removing element from the second. Operations with other elements are not allowed.

  46. Implementing in Linked List Each node will looks like this: typedef struct tagINFO{ int r,i; /* represent a complex number - r(real) and i(imaginary) parts */ }INFO; typedef struct tagNODE{ INFO info; /* information in the queue node*/ struct tagNode *next; /* link to next node*/ }NODE;

  47. Queue Definition typedef struct tagQUEUE{ NODE *head; /* pointer to head of the queue is sufficient, but we use pointer to */ NODE *tail; /* tail also to optimize add/get operations */ }QUEUE;

  48. Operations with Queue • FlushQueue – erase all elements from the queue • Add – add an element to queue • Get – get an element from queue • IsEmpty – check if queue contains no elements • Length – return number of elements in a queue • PrintQueue – print all the elements of the queue

  49. Module with queue - Interface /* Should contain ONLY what is needed to LIBRARY user! */ typedef struct tagINFO{ int r,i; }INFO; struct tagQUEUE; /* !!! */ typedef struct tagQUEUE QUEUE; /* !!! */ void put( QUEUE *q, INFO *info); void get( QUEUE *q, INFO *info); void init_queue(QUEUE **q); /* init queue */ void destroy_queue(QUEUE *q); /* de-initialize queue */ void flush_queue(QUEUE *q); /* clear the queue */ int is_empty(QUEUE *q);

  50. Using the Queue Interface QUEUE *q; INFO a ={1,2}, b = {3,4}, c = {5,6},d; init_queue(&q); put(q,&a); put(q,&b); put(q,&c); get(q, &d); get(q, &d); get(q, &d); destroy_queue(q);

More Related