Example: Runtime Memory Allocation: Example: Dynamical Memory Allocation: Some Comments: Allocate and free dynamic memory

Transcription

1 Runtime Memory Allocation: Examle: All external and static variables Global systemcontrol Suose we want to design a rogram for handling student information: tyedef struct { All dynamically allocated variables malloc, realloc, calloc All auto variables and function call control information Hea Free area Stack user control systemcontrol char name[20]; int grade; student; Question: how to create a table of student records? a) static array: student stable[max_students]; b) dynamic: Table? List? Introduction 1 Introduction 2 Dynamical Memory Allocation: C requires the number of items in an array to be known at comile time. Too big or too small? Dynamical memory allocation allow us to secify an array s size at run time. Two imortant library functions are malloc, which allocates sace from HEAP, and free, which returns the sace (allocated by malloc) back to HEAP for reuse later. Examle: /* allocate and free an array of students, with error check */ #include <stddef.h> // definition of NULL #include <stdlib.h> // definition for malloc/free student *table_create(int n){ student* t; if ((t = malloc(n*sizeof(student)))!= NULL) return t; rintf( table_create: dynamic allocation failed.\n ); exit(0); void table_free(student *t){ if (t!= NULL) free(t); Introduction 3 Introduction 4 Some Comments: Allocate and free dynamic memory #include <stdlib.h> Don t assume malloc will always succeed. Don t assume the dynamically allocated memory is initialized to zero. Don t modify the ointer returned by malloc. free only ointers obtained from malloc, and don t access the memory after it has been freed. Don t forget to free memory which is no longer in use (garbage). void* malloc (size_t n) allocates n bytes and returns a ointer to the allocated memory, the memory is not cleared void* realloc(void*, size_t n) changes the size of the memory block ointed to by to n bytes. The contents will be unchanged to the minimum of the old and new sizes. void* calloc(size_t m, size_t n) allocates memory for an array of m elements of n bytes each, and returns a ointer to the array. void free(void* ) frees the memory block ointed to by. n m old unchanged realloc n bytes each calloc Introduction 5 Introduction 6 1

2 Examle: student table To create a student table dynamically. (1) do not know how many students, (2) keyboard inut Requirement: table holds exact number of ointers to student records; student ** st Array of ointers student student /* creates a student record dynamically and returns the ointer to the student record */ student* make_student(char* name, int grade){ student* s; if ((s = malloc(sizeof (student))) == NULL){ rintf( make_student: dynamic allocation failed.\n ); exit(0); strcy(s->name, name); s->grade = grade; return s; student /* coy s to t, suose t long enough*/ void my_strcy(char* t, char* s){ while (*t++ = *s++); Introduction 7 Introduction 8 #define CHUNK 5 student** make_table(int* num){ int j = 0, maxs = CHUNK, grade; char name[20]; student** st; st = (student**) malloc(maxs*sizeof(student*)); while (2 == scanf( %s%d\n, name, &grade)){ if (j >= maxs){ maxs += CHUNK; st = (student**) realloc(st, maxs*sizeof(student*)); st[j++] = make_student(name, grade); if (j < maxs) st = (student**) realloc(st, j*sizeof(student*)); *num = j; return st; int main(){ student** cis2520; int num; cis2520 = make_table(&num); rintf( The total number of students: %d\n, num); // other rocessing maxs j j: counter of students maxs: number of entries in the table If the table is not big enough, Add another 5 entries; Uon comlete, if the table has unused entries, then return them. Note: we only exand or truncate the ointer array (st), student records are not changed. Introduction 9 Introduction 10 Nested dynamic memory allocation: suose : tyedef struct { char *name; // instead of char name[20] int grade; student; student* make_student(char* name, int grade){ student* s; if ((s = malloc (sizeof (student)))!= NULL && (s->name = malloc(strlen(name) + 1)))!= NULL){ strcy(s->name, name); s->grade = grade; return s; rintf( make_student: dynamic allocation failed. \n ); exit(0); void free_student(student* s){ free(s->name); free(s); // must release name field first Introduction 11 Introduction 12 2

3 Linked list: A linked list reresents a sequence: Every node but one has a redecessor, and every node but one has a successor. t tail /* recursive definition */ tyedef struct node { int data; // whatever useful in the node struct node* next; // link to the next node node; Examle: student list data structure: tyedef structstudent{ char name[20]; int grade; struct student* next; student; make_student function not changed Introduction 13 Introduction 14 student* make_list(int* num){ int j = 0, grade; char name[20]; student *s = NULL, *e = NULL; while (2 == scanf( %s%d\n, name, &grade)){ if (s == NULL) s = e = make_student(name, grade); else { j++; e->next = make_student(name, grade); e = e->next; if (e!= NULL) e->next = NULL; // last node of the list *num = j; return s; int main(){ student* cis2520; int num; cis2520 = make_list(&num); rintf( The total number of students: %d\n, num); // other rocessing cis2520 s e Introduction 15 Introduction 16 Other useful functions: /* find the student record wrt name */ student* find(student* s, char* name){ while (s && (strcm(s->name, name)!= 0)) s = s->next; return s; /* rint student list */ void rint_list(student* s){ while (s){ rintf( Name: %s Grade: %d \n, s->name, s->grade); s = s->next; Recursive versions of rint_list /* rint student list recursively (from to tail)*/ void rint_list_1(student* s){ if (s){ rintf( Name: %s Grade: %d \n, s->name, s->grade); rintf_list_1(s->next); /* rint student list recursively (from tail back to )*/ void rint_list_2(student* s){ if (s){ rintf_list_2(s->next); rintf( Name: %s Grade: %d \n, s->name, s->grade); Introduction 17 Introduction 18 3

4 /* add a new student record after s */ void add_after(student* s, char name*, int grade){ student* new = make_student(name, grade); // (1) new->next = s->next; // (2) s->next = new; // (3) add_after(before call): s A add_after(after call): s A B new (1) new (3) (2) B Q: can we do add_before? Introduction 19 /* delete the student record after s */ void delete_after(student* s){ student* old; if (!s!s->next) return; old = s->next; // (1) s->next = old->next; // (2) free(old); delete_after(before call): s old (1) A delete_after(after call): old s A (2) B B Introduction 20 Linked list vs Array: Array: static storage allocation storage is contiguous random access (index) insert and delete must shift existing data Linked List: dynamic storage allocation storage is not contiguous sequential access only insert and delete do not change existing data Ordered Linked List: Insert nodes in their sorted osition. tyedef struct node{ int data; struct node* next; node; d3 dn where <= <= d3 <= <= dn Introduction 21 Introduction 22 Question: how to insert dk into the list? Case 1: == NULL Case 2:dk should be inserted in front of the list dk <= dk dk dn Case 3:dk should be inserted after a node d3 dn <= dk <= d3 dk can we declare: void insert(node * hd, int data){ suose we have the code: node* = NULL; insert(, 2); insert(, 5); NO, because list will be modified in both Case 1 and Case 2. void insert(node ** h, int data){ node* = NULL; insert(&, 2); insert(&, 5); Introduction 23 Introduction 24 4

5 /* Version 1: insert a new node (data) into a list ointed to by *h */ void insert(node** h, int data){ node* new, * rev == NULL, *curr; new = make_node(data); // suose we have this function curr = *h; // get ointer while (curr && data > curr->data){ // find osition rev = curr; curr = curr->next; if (rev == NULL){ new->next = *h; *h = new; else { rev->next = new; new->next = curr; // or if (!rev) // insert in front // insert after rev /* Version 2: insert a new node (data) into a list ointed to by*h */ void insert(node** h, int data){ node dummy, *new, *; new = make_node(data); = &dummy; dummy.next = *h; while (->next && data > ->next->data) = ->next; new->next = ->next; ->next = new; *h = dummy.next; // suose we have this function // set in dummy // find osition // always insert after Introduction 25 Introduction 26 Version 1: *h Version 2: dummy *h while (curr && data > curr->data){ rev = curr; curr = curr->next; d3 dn while (->next && data > ->next ->data) = ->next; d3 dn Suose: A B C D E F G H node *, *, *q, *tem; int data; = ; q = NULL; Introduction 27 Introduction 28 /* delete the node (data) from a list ointed to by *h */ void delete(node** h, int data){ node dummy, *old, *; = &dummy; dummy.next = *h; // set in dummy while (->next && data!= ->next->data) // find osition = ->next; if (->next){ old = ->next; // get the node to be deleted ->next = ->next->next; free(old); // free the node *h = dummy.next; Doubly Linked List: A list which can be traversed either forward or backward: tyedef struct node{ int data; struct node* next; struct node* rev; node; Introduction 29 Introduction 30 5

6 Insert oeration: Insert oeration: insert_after: insert_before: new->next = ->next; // 1 (red link) new->next = ; // 1 (red link) new->rev = ; ->next = ->next->rev = new; // 2 (green link) // 3 (blue links) new->rev = ->rev; ->rev= ->rev->next = new; // 2 (green link) // 3 (blue links) new 3 1 new Introduction 31 Introduction 32 Examle: Suose we have a doubly linked list: (1) find the mid node, (2) along mid s rev link, decrease each node value by 2, along mid s next link (include mid node), increase each node value by mid +5 d3 d4 d5 #define NEXT 0 #define PREV 1 tyedef struct node{ int data; struct node *link[2]; node; void traverse(node*, int dir, void (*f)(node*)){ while (){ (*f)(); // call function f with argument = ->link[dir]; void dec2(node* ){ ->data -= 2; void inc5(node* ){ ->data += 5; Introduction 33 Introduction 34 void rocessing(node* ){ node* mid = ; while ( && ->link[next] && ->link[next]->link[next]){ mid = mid->link[next]; = ->link[next]->link[next]; traverse(mid, PREV, dec2); // any roblem here? traverse(mid, NEXT, inc5); Function Pointer: tye (*f)(arameter_list); Generic Functions: A generic function is one that can work on any underlying C data tye. Generic functions allow us to reuse rograms by adding a small iece of tye-secific code. For examle, standard C library rovides two generic functions: bsearch searches an arbitrary array, and qsort sorts an arbitrary array. Function name is the ointer to that function. Introduction 35 Introduction 36 6

7 Review of Pointers to Functions: A ointer to a function contains the address of the function in memory. Similar to an array name which is the starting address of the first array element, a function name is the starting address of the function code. Pointers to functions can be assed to functions, returned from functions, stored in an array, and assigned to other function ointers. Pointers to Functions: int comare(int a, int b){ // imlementation int main(){ int cr1, cr2; int (*f)(int, int); // declare a ointer to function f = comare; // assign a function ointer tof cr1 = (*f)(2, 3); // call the function cr2 = f(2, 3); // same as above but not recommended Introduction 37 Introduction 38 Binary search function: binary search is used to find a target value in a sorted table. we start by comaring the target value with the table s middle element. since the table is sorted, so if the target is larger, we can ignore all values smaller than the middle element, and vice versa. We sto when we ve found the target or no values left to search. int* bsearch(int target, int *table, int n){ int *min = table; int *max = table + (n 1); int *mid; int k = n/2; while (min < max) { mid = min + k; if (target == *mid) return mid; else if (target > *mid) min = mid + 1; else max = mid - 1; k /= 2; return NULL; Introduction 39 Introduction 40 Generic Binary Search: void * bserach(const void *target, const void *table, size_t n, size_t size, int (*cmf)(const void *, const void*)); min target = mid min mid max max target: a ointer to the element we are searching for table: the array we are searching n: the size of the array size: the size of an array element cmf: a ointer to a function to comare the target and an element table target n size min mid max Target element Introduction 41 Introduction 42 7

8 bsearch Function: void * bserach(const void *target, const void *table, size_t n, size_t size, int (*cmf)(const void *, const void*)){ void *min = table, *max = table + (n 1)*size; void *mid; int k = n/2; int cr; while (min < max) { mid = min + k*size; cr = (*cmf )(target, mid) ; if (cr == 0) return mid; else if (cr > 0) min = mid + size; else max = mid - size; k /= 2; return NULL; Invoking bsearch: bsearch returns a ointer to the matching array element if it finds one, or NULL otherwise. Suose we have an int table inttable and a string table stringtable, we might call: int key = 78; int* i = bsearch(&key, inttable, ISIZE, sizeof(int), cmint); char* s = bsearch( Tom Wilson, stringtable, SSIZE, sizeof (stringtable[0]), cmstr); Introduction 43 Introduction 44 Tye-secific Functions: int cmint(const void *t, const void *e){ int it = *(int*) t; // get target value int ie = *(int*) e; // get array element value return (it == ie)? 0 : ((it < ie)? 1 : 1); int cmstr(const void *t, const void *e){ char *ct = (char*) t; // casting target to char ointer char *ce = *(char**) e; // get array element value (a char ointer) return strcm(ct, ce); (1) Write a comarison function: int cmstudent(const void* t, const void *s); which calls strcm to comare two student names. (2) suose a new student and a ointer variable are defined as follows: struct student s = {"John Smith", 21; struct student *; Write the call statement to bsearch to find if s is in stable and assign the returned value to. Introduction 45 Introduction 46 8