Functions:"" Breaking"large"computing"tasks"to" smaller"ones"

Size: px

Start display at page:

Download "Functions:"" Breaking"large"computing"tasks"to" smaller"ones""

Allen Floyd
5 years ago
Views:

1 Lecture'3'(P a rt1):'''''''' ' 0 3 ' C 'Programm E S C ing'' 1

2 Functions:"" Breaking"large"computing"tasks"to" smaller"ones" 2

3 C'Programming' 'Procedural'thought'process' main%()%/*%high%level%outline%*/% {% %%.%.%.% %%get_input(arg1)%/*comment:%step%1%*/% %%perform_step_2(arg2);%% %%perform_step_3();% %%store_result();%/*%print%output%or%store%in%a%file%*/% % }% ' 3

4 Overview'of'Functions' Functions'make'code'easy'to''! Maintain'! Debug'! Reuse' 4

5 Functions'Overview' void%foo(int%x,%int%y);%%//declaration" 5

6 //De5inition" Functions'Overview' void%foo(int%x,%int%y)%{% %%%int%tmp;% %%%tmp=%x;% %%%x=%y;% %%%y=%tmp;%%}%% What'does'foo'do?' tmp' x' foo' y' 6

7 Stack'Allocation:'Function'local' variables'and'parameters' When'program'execution'starts' Local'variables'of'func()' Other'information'about' func()' Local'variables'of'main()' What'if'main'calls'the'function'func()?' Stack'Pointer' 7

8 Stack'Allocation:'Function'local' variables'and'parameters' Variables'whose'lifetime'is'the'execution'time'of' function'are'managed'using'the'stack'structure' Local'variables'of'main()' Stack'Pointer' 8

9 Variables'declared'within'a'function'' A. can'be'used'by'other'functions' ' B. can'only'be'used'within'the'function'' C. continue'to'exist'in'memory'as'long'as'the' program'executes' ' 9

10 Consider'the'following'function' void%swap(int%x,%int%y);%% //Declaration" void%swap(int%x,%int%y)%{% %%%int%tmp;% %%%tmp=%x;% %%%x=%y;% %%%y=%tmp;%%}%% tmp' x' swap' y' The'swap'function'intends'to'swap'the'value' of'its'inputs.'is'the'logic'correct?' A. Yes' B. No' C. Depends' 10 x' y'

11 Q:'Are'the'value'of'variables' a 'and' b ' interchanged'after'swap'is'called?' main()%{% %%.%.%.% %%swap(a,%b);% %%.%.%.%.%}%% a' 5' 6' b' ' A. Yes,'because'..' B. No,'because..' ' ' 11

12 Q:'Which'of'the'following'changes'are'required'to' interchange'the'values'in' a 'and' b 'when'swap'is'called?' {%.%.%.%.% %swap(a,%b);% 5' 6' x' y' a' b' }%% swap' ' A. In'swap,'return'the'values'of' x 'and' y 'to'the'main'function' after'swapping'them' B. Declare' a 'and' b 'as'global'variables,'so'that'they'become' accessible'to'the'swap'routine' C. Pass'the'address'of' a 'and' b 'to'swap'instead'of'their'value' D. Move'the'implementation'in'swap'to'the'main'function'' ' 12

In'swap,'return'the'values'of' x 'and' y 'to'the'main'function' after'swapping'them' B.

13 Q:'Which'of'the'following'changes'are'required'to' interchange'the'values'in' a 'and' b 'when'swap'is'called?' {%.%.%.%.% %swap(a,%b);% 5' 6' x' y' a' b' }%% swap' ' A. In'swap,'return'the'values'of' x 'and' y 'to'the'main'function' after'swapping'them' B. Declare' a 'and' b 'as'global'variables,'so'that'they'become' accessible'to'the'swap'routine' C. Pass'the'address'of' a 'and' b 'to'swap'instead'of'their'value' D. Move'the'implementation'in'swap'to'the'main'function'' ' 13

14 Functions:'Call'by'reference' Q:'What'should'the'modi[ied'swap'function'do?' ' void%swap(int%*x,%int%*y)%{% %%%.%.%.% }%% A. Swap'the'addresses''in' x 'and' y ' B. Swap'the'values'pointed'to'by' x 'and' y ' C. Both'the'above'operations'are'equivalent' ' 14

15 Functions:'Call'by'reference' Q:'What'should'the'modi[ied'swap'function'do?' ' void%swap(int%*x,%int%*y)%{% %%%.%.%.% }%% A. Swap'the'addresses''in' x 'and' y ' B. Swap'the'values'pointed'to'by' x 'and' y ' C. Both'the'above'operations'are'equivalent' ' 15

16 void IncrementPtr(int *p){ p = p + 1; } Q: What happens when IncrementPtr(q)is called in the following code: A q int A[3] = {50, 60, 70}; int *q = A; IncrementPtr(q);' A. The pointer q points to the next element in the array with value 60 B. The pointer q points to the first element in the array with value 50

17 void IncrementPtr(int *p){ p = p + 1; } Q: What happens when IncrementPtr(q)is called in the following code: A q int A[3] = {50, 60, 70}; int *q = A; IncrementPtr(q);' A. The pointer q points to the next element in the array with value 60 B. The pointer q points to the first element in the array with value 50

18 void IncrementPtr(int **p){ p = p + 1; } Q: How should we implement IncrementPtr(),so that q moves by one element when the following code executes? int A[3] = {50, 60, 70}; int *q = A; IncrementPtr(&q);' A q A. p = p + 1; //The current one is correct B. &p = &p + 1; C. *p= *p + 1; D. *p++; E. p= &p+1;

19 void IncrementPtr(int **p){ p = p + 1; } Q: How should we implement IncrementPtr(),so that q moves by one element when the following code executes? int A[3] = {50, 60, 70}; int *q = A; IncrementPtr(&q);' A q A. p = p + 1; //The current one is correct B. &p = &p + 1; C. *p= *p + 1; D. *p++; E. p= &p+1;

20 Derived"data"types:" Structures"

21 C structures : Overview A struct is a data structure composed of simpler data types. Like a class in Java/C++ but without methods or inheritance. struct point { int x; int y; } void PrintPoint(struct point p) { printf( (%d,%d), p.x, p.y); }

22 Pointers to structures The C arrow operator (->) dereferences and extracts a structure field with a single operator. The following are equivalent: struct point *p; printf( x is %d\n, (*p).x); printf( x is %d\n, p->x);

23 Representation in memory struct p { int y; char x; }; struct p sp; sp' y'(4'bytes)' x'(1byte)' 0x100' 0x104' 0x105'

24 struct p { char x; int y; }; Struct p sp; Data Alignment Q: How is the above struct laid out in memory?

Alignment Fundamentals Processors do not always access memory in byte sized chunks, instead in 2, 4, 8, even 16 or 32 byte chunks Boundaries at which data objects are

25 Alignment Fundamentals Processors do not always access memory in byte sized chunks, instead in 2, 4, 8, even 16 or 32 byte chunks Boundaries at which data objects are stored affects the behavior of read/write operations into memory 0x00' 0x01' 0x02' 0x03' 0x04' 0x05' Programmer's'view' of'memory' 0x00' 0x02' 0x04' Processor s'view'of' memory'

26 Alignment Fundamentals Consider the task of reading 4 bytes from memory starting at 0x00 for processors that read 1, 2, 4 bytes at a time. How many memory accesses are needed in each case? 0x00' 0x01' 0x02' 0x03' 0x04' 0x05' 0x00' 0x01' 0x02' 0x03' 0x04' 0x05' 0x00' 0x02' 0x04' 0x00' 0x04' Memory' 1'byte'reads' 2'byte'reads' 4'byte'reads'

27 Alignment Fundamentals Now consider the task of reading 4 bytes from memory starting at 0x01 for processors that read 1, 2, 4 bytes at a time. How many memory accesses are needed in each case? 0x00' 0x01' 0x02' 0x03' 0x04' 0x05' Some processors just would not allow this scenario because it is extra work for the h/w and it affects the performance 0x00' 0x01' 0x02' 0x03' 0x04' 0x05' 0x00' 0x02' 0x04' 0x00' 0x04' Memory' 1'byte'reads' 2'byte'reads' 4'byte'reads' Additional'operations'needed'to'get' required'bytes'

28 Alignment requirements Data objects should start at memory addresses that are divisible by the size of the data object. short (2 byte) at address divisible by 2 0b _ 0 int (4 byte) at address divisible by 4 0b 00 double (8 byte) at address divisible by 8 0b 000

29 Alignment requirements Q: How is sp laid out in memory? Compiler takes care of zero padding struct p { char x; int y; }; struct p sp;

30 Alignment requirements Q: How is sp laid out in memory? Compiler takes care of zero padding struct p { char x; int y; }; struct p sp; sp' 0x100' x'' 0''0''0'' 0x104' y'' 0x108'

31 How big are structs? Recall C operator sizeof() which gives size in bytes (of type or variable) Q: How big is sizeof(struct p)? struct p { char x; int y; }; A. 5 bytes B. 8 bytes C. 12 bytes

32 Data' Linked Lists Node'1' Node'2' Node'3'

33 Linked Lists Node'1' Node'2' Node'3' Data' A'generic'linked'list'has:'! Multiple'data'objects'(structs)'also'called'nodes'! Each'node'linked'to'the'next'node'in'the'list'i.e.'it'knows'the' address'of'the'next'node'! Nodes'located'at'different'memory'locations'(unlike'arrays' where'they'are'contiguous)' Advantages'compared'to'arrays'! Multiple'data'members'(of'different'data'types)'can'be'stored' in'each'node'! Nodes'can'be'easily'inserted'or'removed'from'the'list'without' modifying'the'whole'list'

34 Let s look at an example of using structures, pointers, malloc(), and free() to implement a linked list of strings. typedef struct Node node; struct Node { char *value; next; }; node' value' Q:What is the data type of the variable next? A. struct Node B. Node C. node D. node * next'

35 Let s look at an example of using structures, pointers, malloc(), and free() to implement a linked list of strings. typedef struct Node node; struct Node { char *value; next; }; node' value' Q:What is the data type of the variable next? A. struct Node B. Node C. node D. node * next'

36 Adding a node to the list node *list_add(node* head, char *string) { //Step 1:Create a new node ; return new_node; value=?' } new_node' Q: How should we declare and initialize new_node? next=?' A. node *new_node=(node*) malloc(sizeof(node)); B. node new_node; C. node *new_node=head; D. node *new_node=(node *)malloc(sizeof(head));

38 Adding a node to the list node *list_add(node* head, char *string) { //Step 1:Create a new node ; return new_node; value=?' } new_node' Q: How should we declare and initialize new_node? next=?' A. node *new_node=(node*) malloc(sizeof(node)); B. node new_node; C. node *new_node=head; D. node *new_node=(node *)malloc(sizeof(head));

39 Q:What is wrong with step 2? node *list_add(node* head, char *string) { node *new_node=(node*) malloc(sizeof(node)); }

40 Q:What is wrong with step 2? node *list_add(node* head, char *string) { node *new_node=(node*) malloc(sizeof(node)); //Step 2: Fill in its value strcpy(new_node->value, string); return new_node; } A. Step 2 is correct. B. We should use the operator. instead of -> C. Memory is not allocated for value

41 Q:What is wrong with step 2? node *list_add(node* head, char *string) { node *new_node=(node*) malloc(sizeof(node)); //Step 2: Fill in its value strcpy(new_node->value, string); return new_node; } A. Step 2 is correct. B. We should use the operator. instead of -> C. Memory is not allocated for value

42 Draw pointer diagrams node *list_add(node* head, char *string) { node *new_node=(node*) malloc(sizeof(node)); new_node->value = (char*) malloc(strlen(string)+1); strcpy(new_node->value, string); }

43 What should Step 3 be? node *list_add(node* head, char *string){ node *new_node=(node*) malloc(sizeof(node)); new_node->value = (char*) malloc(strlen(string)+1); strcpy(new_node->value, string); //Step 3: } A. new_node->next =head; B. next=head; C. head=new_node; D. new_node->next =*head;

44 What should Step 3 be? node *list_add(node* head, char *string){ //Step 1: Create a new node node *new_node=(node*) malloc(sizeof(node)); //Step 2: Fill in its value new_node->value = (char*) malloc(strlen(string)+1); strcpy(new_node->value, string); //Step 3: Link new_node to the head of the list new_node->next =head; return new_node; } new_node' head" A. new_node->next =head; B. next=head; C. head=new_node; D. new_node->next =*head; value ' abc ' next' NULL'

45 Dangling pointers and memory leaks Dangling reference : Pointer points to a memory location that no longer exists Memory leaks (tardy free) Memory in heap that can no longer be accessed

46 Q: Which of the following functions returns a pointer to an object that may not exist in memory? int * f1(int num){ int *mem1 =(int *)malloc(num*sizeof(int)); return(mem1);} int * f2(int num){ int mem2[num]; return(mem2);} A. f1 B. f2 C. Both

47 Q: Which of the following functions returns a pointer to an object that may not exist in memory? int * f1(int num){ int *mem1 =(int *)malloc(num*sizeof(int)); return(mem1);} int * f2(int num){ int mem2[num]; return(mem2);} A. f1 B. f2 because mem2 is a local variable created in the stack C. Both

48 Which'of'the'following'is'an' example'of'a'dangling'pointer?' A. void'foo(int'bytes)''{' '''''''char'*ch'=(char'*)'malloc(bytes);' ''''''''.'.'.'.' ''''''''free'(ch);' ''''''''.'.'.'.}' ' B.''''int'*'foo(int'bytes)''{' '''''''int'i=14;' ''''''''.'.'.'.' ''''''''return'(&i);' ''''''''}' C.'''char*'foo(int'bytes)''{' '''''''char'*ch'=(char'*)'malloc(bytes);' ''''''''.'.'.'.' ''''''''return'(ch);' ''''''''}''''' D.''A'combination'of'the' above''''''

49 Which'of'the'following'is'an' example'of'a'dangling'pointer?' A. void'foo(int'bytes)''{' '''''''char'*ch'=(char'*)'malloc(bytes);' ''''''''.'.'.'.' ''''''''free'(ch);' ''''''''.'.'.'.}' ' B.''''int'*'foo(int'bytes)''{' '''''''int'i=14;' ''''''''.'.'.'.' ''''''''return'(&i);' ''''''''}' C.'''char*'foo(int'bytes)''{' '''''''char'*ch'=(char'*)'malloc(bytes);' ''''''''.'.'.'.' ''''''''return'(ch);' ''''''''}''''' D.""A"combination"of" the"above""""""

50 Memory'Leak' Is'the'following'an'example'for'a'memory'leak?' 'void'foo'(int'bytes)' '{' ''''int'*p'='(int'*)'malloc(bytes);' '''}'

51 The'C'runtime'environment' 50

52 What'does'the'executable'contain?' Instructions'or' code ' Data''' ''What'is'data?' ' '" Any'information'that'instructions'operate'on' (objects'in'memory)' 51

53 C'Runtime'Environment'' Code '(instructions'in'machine'language)' Data '(initialized'and'uninitialized'j'static' allocated)' Both'code'and'data'don t'change'in'size'' Heap '(for'dynamically'allocated'data)' Stack '(for'function'local'variables)' Heap'and'stack'change'in'size'as'the'program' executes' ' 52

54 C'Runtime'Environment' Code' Initialized'Data' Uninitialized'Data' Heap' Stack' 53

55 Data'lifetime' Lifetime:'The'interval'between'time'of' creation'and'end'of'existence'of'data' 54

56 Possible'lifetimes'of'data' 1. Execution'time'of'program' 2. Time'between'explicit'creation'and'explicit' deletion' 3. Execution'time'of'a'function'(time'between' function'call'and'function'return)' ' 55

57 Declarations'and'de[initions' Scope'and'lifetime'are'often'implicit'but' sometimes'we'have'to'use'speci[ic'keywords:' ' %static%int%a=0;%/*de[ines'lifetime*/' %extern%int%a;%%/*extends'scope'to'multiple' [iles*/' %% 56

58 Different'types'of'data' What'factor'differentiates'the'following'three' categories 'of'data'in'a'c'program:' Global'and'static'variables' Local'variables' Dynamic'variables' A. Scope' B. Lifetime' C. Representation' 57

59 Different'types'of'data' What'factor'differentiates'the'following'three' categories 'of'data'in'a'c'program:' Global'and'static'variables' Local'variables' Dynamic'variables' A. Scope' B. Lifetime' C. Representation' 58

Lecture 5: Outline. I. Multi- dimensional arrays II. Multi- level arrays III. Structures IV. Data alignment V. Linked Lists

Lecture 5: Outline. I. Multi- dimensional arrays II. Multi- level arrays III. Structures IV. Data alignment V. Linked Lists Lecture 5: Outline I. Multi- dimensional arrays II. Multi- level arrays III. Structures IV. Data alignment V. Linked Lists Multidimensional arrays: 2D Declaration int a[3][4]; /*Conceptually 2D matrix