Presentation is loading. Please wait.

Presentation is loading. Please wait.

Pointers 2 COP3275 – PROGRAMMING USING C DIEGO J. RIVERA-GUTIERREZ.

Published byMelanie Newman Modified over 9 years ago

Similar presentations

Presentation on theme: "Pointers 2 COP3275 – PROGRAMMING USING C DIEGO J. RIVERA-GUTIERREZ."— Presentation transcript:

1 Pointers 2 COP3275 – PROGRAMMING USING C DIEGO J. RIVERA-GUTIERREZ

2 Administrative stuff Quiz on Friday Easy question on pointers (regarding basic operators + malloc) (15 pts) Create one function that does an operation to the list we will create today (15 pts) String function (15 pts) Free credit question. (Every answer is correct for this one – 5pts) Homework #5 will be posted tonight.

3 Homework #5 Allow different sizes of boards! Move seed, # of mines and board size to console arguments. -s for seed -m for mines -r for rows -c for columns Include mine counter (#mines – mines assigned) Winning condition – including when all unopened tiles are mines Due on July 24 th.

4 Let’s build a better list… We have a struct that saves all the info for a student (name, UFID, DOB, major, year, etc). struct student{ char *name; int UFID; char major[3]; struct Date DOB; int year; };

5 Let’s build a better list… For simplicity let’s only use name struct student{ char *name; struct student *next; };

6 Remember what we are after: AnaAndrewCristinaJulianaMichael

7 On Monday – Creation of the list struct student ana; ana.name = "Ana"; struct student andrew; andrew.name = "Andrew"; ana.next = &andrew; That works fine. But it’s not ideal. Very manual.. We want functions to handle operations so we likely want an “add” function.

8 What functions we need? Add Add keeping alphabetical order! Delete Search?

9 The add function What are our parameters? Current list Element to add What’s the current list at the very beginning? What would you consider to be an “empty” list? NULL! Do we need a return value? Yes! Why? To be able to delete the front!

10 Add function Return type: struct student * Name: Add Parameter 1: struct student * current_list Parameter 2: ? char * name? struct student s1? struct strudent *s2?

11 Add function struct student *add(struct student *list, char* name) { struct student s; s.name = name; s.next = NULL; if(list == NULL) { return &s; }else { struct student *pos = list; while((*pos).next != NULL) { pos = (*pos).next; } (*pos).next = &s; return list; } } Note: This has a major error!

12 Before we get to the error – The ‘->’ operator The notation (*pos).next is kind of annoying. Having to “de-reference” the pointer to access the struct’s elements is a very common task We have a special operator that does this! The ‘->’ operator So if ptr is a pointer to a struct that has id as one of the its elements: ptr->id is equivalent to (*ptr).id pos->next is equivalent to (*pos).next

13 The -> operator struct student *add(struct student *list, char* name) { struct student s; s.name = name; s.next = NULL; if(list == NULL) { return &s; }else { struct student *pos = list; while(pos->next != NULL) { pos = pos->next; } pos->next = &s; return list; } } Note: This has a major error!

14 If we compile that, we get a warning about the error! list.c:17:3: warning: function returns address of local variable [-Wreturn-local-addr] return &s; ^ The warning is pretty clear. We are returning the memory address of a “local variable” If you remember from our discussion on scopes: A “local variable” is a variable defined inside a function As opposed o a “global variable” that is accessible in the full scope of the program

15 So what’s the error? struct student *add(struct student *list, char* name) { struct student s; s.name = name; s.next = NULL; if(list == NULL) { return &s; }else { struct student *pos = list; while(pos->next != NULL) { pos = pos->next; } pos->next = &s; return list; } }

16 Ok… so maybe we could receive the struct? struct student *add(struct student *list, struct student s) { if(list == NULL) { return &s; }else { struct student *pos = list; while(pos->next != NULL) { pos = pos->next; } pos->next = &s; return list; } } This is still an issue… Structs are passed by value And parameters are also local variables…

17 Can we finally see one version that runs? struct student *add(struct student *list, struct student *s) { if(list == NULL) { return s; }else { struct student *pos = list; while(pos->next != NULL) { pos = pos->next; } pos->next = s; return list; } }

18 Ok are we happy with add now? Nope. But, why? Right now to add a new student we need to do something like this: struct student s = {.name = “Name”,.next = NULL}; list = add(list, &s); What happens if the user can input the students? How many struct student do we need to allocate? We could potentially allocate an array so that we have structs to take from. The problem with that is: how many are enough? What happens if the user wants just one more than we gave them? It becomes very inneficcient. The solution: malloc!

19 malloc (also in the Advanced Features Chapter) REALLY? Advanced features??? And pointer arithmetic is part of the pointer chapter?? Sorry I needed to complain about that decision the book author made. malloc is defined in stdlib.h It stands for memory allocation. Malloc “dynamically” allocates memory It receives a single parameter of type size_t with the number of bytes to allocate size_t is a custom type and it’s actual meaning is platform (computer) dependent Usually it is an unsigned long int (but not necessarily) We’ve seen size_t before when we talked about the sizeof function. It returns a void* (a pointer to type void). This is C’s “generic” pointer. It can point to anything! Including code (recall my awkward discussion about calling functions without a name)

20 malloc So how do I use it? int *ptr_int = (int*)malloc(4); Wait don’t use it like that…. Even if we know that an int is 4 bytes for most of our uses…. This ties our code to architectures that use 4 byte integers. The correct way of using it: int *ptr_int = (int*)malloc(sizeof(int));

21 malloc – Graphically explained int *ptr_int; ptr_int = (int*)malloc(sizeof(int)); ?

22 malloc – Graphically explained int *ptr_int; ptr_int = (int*)malloc(sizeof(int)); ? At this point this piece of memory is not named. It is valid memory, but it’s not tied to a variable name.

23 malloc – Graphically explained int *ptr_int; ptr_int = (int*)malloc(sizeof(int)); ?

24 So how do we use it for our add function? struct student *add(struct student *list, char* name) { struct student s; s.name = name; s.next = NULL; if(list == NULL) { return &s; }else { struct student *pos = list; while((*pos).next != NULL) { pos = (*pos).next; } (*pos).next = &s; return list; } }

25 So how do we use it for our add function? struct student *add(struct student *list, char* name) { struct student *s = (struct student*) malloc(sizeof(struct student)); s->name = name; s->next = NULL; if(list == NULL) { return s; }else { struct student *pos = list; while((*pos).next != NULL) { pos = (*pos).next; } (*pos).next = s; return list; } }

26 Delete function We will delete by index (same as we did before). void delete(struct student *list, int index) { struct student *prev; struct student *current = list; while(index > 0 ) { index--; prev = current; current = current->next; } prev->next = current->next; }

27 Allowing deleting the head (We all want to get rid of Ana) Ok she is my best friend, so no we don’t…. But if we did... The current way doesn’t support that. We can do it recursively (and we also don’t need to take into account the previous! Which is cool!) struct student *delete2(struct student *list, int index) { if(index == 0) { return list->next; }else { list->next = delete2(list->next, index-1); return list;}

28 Freeing memory We are dynamically asking for memory. Remember memory is a limited resource. It is BIG for most of our applications. But it’s not infinite. Every time we call malloc, we are making a commitment to use that memory and eventually free it. Not freeing memory is bad… It’s like punching your mom… like that bad… Ok maybe not THAT bad…. When the program ends, all memory gets reclaimed OS programmers are smart dudes… But we should always try to use memory responsibly

29 Freeing memory free is the function we use to free up memory we have created using malloc. free receives any pointer, it goes to that piece of memory and let’s the OS reclaim the memory. free(ptr_int);

30 Delete function struct student *delete(struct student *list, int index) { struct student *prev; struct student *current = list; while(index > 0 ) { index--; prev = current; current = current->next; } prev->next = current->next; free(current); return list; }

31 Recursive delete struct student *delete(struct student *list, int index) { if(index == 0) { struct student *next = list->next; free(list); return next; }else { list->next = delete(list->next, index-1); return list;} Why like that?

32 Pointers FRIDAY JULY, 10 TH

33 Administrative Stuff Quiz today. Quiz #5 grades were released yesterday. Homework #5 was posted. The solution to Homework #4 was also posted. Let’s check the homework specification.

34 Recursive delete struct student *delete2(struct student *list, int index) { if(index == 0) { struct student *next = list->next; free(list); return next; }else { list->next = delete2(list->next, index-1); return list;}

35 Recursive delete struct student *delete2(struct student *list, int index) { if(index == 0) { return list->next; }else { list->next = delete2(list->next, index-1); return list;}

36 AnaAndrewCristinaJulianaMichael struct student *delete2(struct student *list,int index) { if(index == 0) { return list->next; }else { list->next = delete2(list->next, index-1); return list;} list = delete2(list, 2); list

37 delete2(list, 2)

38 list delete2(, 2) AnaAndrewCristina Juliana Michael struct student *delete2(struct student *list, int index) { if(index == 0) { return list->next; }else { list->next = delete2(list->next, index-1); return list;}

39 list delete2(, 2 ) AnaAndrewCristina Juliana Michael struct student *delete2(struct student *list, int index) { if(index == 0) { return list->next; }else { list->next = delete2(list->next, index-1); return list;}

40 list delete2(, 2) AnaAndrewCristina Juliana Michael struct student *delete2(struct student *list, int index) { if(index == 0) { return list->next; }else { list->next = delete2(list->next, index-1); return list;}

41 list delete2(, 2) AnaAndrewCristina Juliana Michael struct student *delete2(struct student *list, int index) { if(index == 0) { return list->next; }else { list->next = delete2(list->next, index-1); return list;}

42 list delete2(, 2) AnaAndrewCristina Juliana Michael struct student *delete2(struct student *list, int index) { if(index == 0) { return list->next; }else { list->next = delete2(list->next, index-1); return list;}

43 list delete2(, 2) AnaAndrewCristina Juliana Michael struct student *delete2(struct student *list, int index) { if(index == 0) { return list->next; }else { list->next = delete2(list->next, index-1); return list;} delete2(, 2-1)

44 list delete2(, 2) AnaAndrewCristina Juliana Michael struct student *delete2(struct student *list, int index) { if(index == 0) { return list->next; }else { list->next = delete2(list->next, index-1); return list;} delete2(, 1)

45 list delete2(, 2) AnaAndrewCristina Juliana Michael struct student *delete2(struct student *list, int index) { if(index == 0) { return list->next; }else { list->next = delete2(list->next, index-1); return list;} delete2(, 1)

46 list delete2(, 2) AnaAndrewCristina Juliana Michael struct student *delete2(struct student *list, int index) { if(index == 0) { return list->next; }else { list->next = delete2(list->next, index-1); return list;} delete2(, 1)

47 list delete2(, 2) AnaAndrewCristina Juliana Michael struct student *delete2(struct student *list, int index) { if(index == 0) { return list->next; }else { list->next = delete2(list->next, index-1); return list;} delete2(, 1)

48 list delete2(, 2) AnaAndrewCristina Juliana Michael struct student *delete2(struct student *list, int index) { if(index == 0) { return list->next; }else { list->next = delete2(list->next, index-1); return list;} delete2(, 1) delete2(, 1-1)

49 list delete2(, 2) AnaAndrewCristina Juliana Michael struct student *delete2(struct student *list, int index) { if(index == 0) { return list->next; }else { list->next = delete2(list->next, index-1); return list;} delete2(, 1) delete2(, 0)

50 list delete2(, 2) AnaAndrewCristina Juliana Michael struct student *delete2(struct student *list, int index) { if(index == 0) { return list->next; }else { list->next = delete2(list->next, index-1); return list;} delete2(, 1) delete2(, 0)

51 list delete2(, 2) AnaAndrewCristina Juliana Michael struct student *delete2(struct student *list, int index) { if(index == 0) { return list->next; }else { list->next = delete2(list->next, index-1); return list;} delete2(, 1) delete2(, 0)

52 list delete2(, 2) AnaAndrewCristina Juliana Michael struct student *delete2(struct student *list, int index) { if(index == 0) { return list->next; }else { list->next = delete2(list->next, index-1); return list;} delete2(, 1) delete2(, 0)

53 list delete2(, 2) AnaAndrewCristinaJulianaMichael struct student *delete2(struct student *list, int index) { if(index == 0) { return list->next; }else { list->next = delete2(list->next, index-1); return list;} delete2(, 1) delete2(, 0)

54 list delete2(, 2) AnaAndrewCristinaJulianaMichael struct student *delete2(struct student *list, int index) { if(index == 0) { return list->next; }else { list->next = delete2(list->next, index-1); return list;} delete2(, 1) delete2(, 0)

55 list delete2(, 2) AnaAndrewCristinaJulianaMichael struct student *delete2(struct student *list, int index) { if(index == 0) { return list->next; }else { list->next = delete2(list->next, index-1); return list;} delete2(, 1) delete2(, 0)

56 list delete2(, 2) AnaAndrewCristinaJulianaMichael struct student *delete2(struct student *list, int index) { if(index == 0) { return list->next; }else { list->next = delete2(list->next, index-1); return list;} delete2(, 1) delete2(, 0) Juliana

57 list delete2(, 2) AnaAndrewCristinaJulianaMichael struct student *delete2(struct student *list, int index) { if(index == 0) { return list->next; }else { list->next = delete2(list->next, index-1); return list;} delete2(, 1) Juliana

58 list delete2(, 2) AnaAndrewCristinaJulianaMichael struct student *delete2(struct student *list, int index) { if(index == 0) { return list->next; }else { list->next = delete2(list->next, index-1); return list;} delete2(, 1) Juliana

59 list delete2(, 2) AnaAndrewCristinaJulianaMichael struct student *delete2(struct student *list, int index) { if(index == 0) { return list->next; }else { list->next = delete2(list->next, index-1); return list;} delete2(, 1) Juliana

60 list delete2(, 2) AnaAndrewCristinaJulianaMichael struct student *delete2(struct student *list, int index) { if(index == 0) { return list->next; }else { list->next = delete2(list->next, index-1); return list;} Juliana

61 list delete2(, 2) AnaAndrewCristinaJulianaMichael struct student *delete2(struct student *list, int index) { if(index == 0) { return list->next; }else { list->next = delete2(list->next, index-1); return list;} Juliana

62 list delete2(, 2) AnaAndrewCristinaJulianaMichael struct student *delete2(struct student *list, int index) { if(index == 0) { return list->next; }else { list->next = delete2(list->next, index-1); return list;} Juliana

63 list delete2(, 2) AnaAndrewCristinaJulianaMichael struct student *delete2(struct student *list, int index) { if(index == 0) { return list->next; }else { list->next = delete2(list->next, index-1); return list;} Juliana

64 list delete2(, 2) AnaAndrewCristinaJulianaMichael struct student *delete2(struct student *list, int index) { if(index == 0) { return list->next; }else { list->next = delete2(list->next, index-1); return list;} Juliana

65 list AnaAndrewCristinaJulianaMichael struct student *delete2(struct student *list, int index) { if(index == 0) { return list->next; }else { list->next = delete2(list->next, index-1); return list;} Juliana

66 list AnaAndrewCristinaJulianaMichael list = delete2(list, 2); Juliana

67 list AnaAndrewCristinaJulianaMichaelJuliana

68 list AnaAndrewCristinaJulianaMichael void print(struct student *head) { while(head != NULL) { printf("%s\n", (*head).name); head = (*head).next; }

69 list AnaAndrewCristinaJulianaMichael void print(struct student *head) { while(head != NULL) { printf("%s\n", head->name); head = head->next; }

70 list AnaAndrewCristinaJulianaMichael void print(struct student *head) { while(head != NULL) { printf("%s\n", head->name); head = head->next; } print(list);

71 list AnaAndrewCristinaJulianaMichael void print(struct student *head) { while(head != NULL) { printf("%s\n", head->name); head = head->next; } print(list); Cristina is no longer accessible from the Head (list). However, she is still in memory.

72 list delete2(, 2) AnaAndrewCristinaJulianaMichael struct student *delete2(struct student *list, int index) { if(index == 0) { struct student *next = list->next; free(list); return next; }else { list->next = delete2(list->next, index-1); return list;} delete2(, 1) delete2(, 0)

73 list delete2(, 2) AnaAndrewCristinaJulianaMichael struct student *delete2(struct student *list, int index) { if(index == 0) { struct student *next = list->next; free(list); return next; }else { list->next = delete2(list->next, index-1); return list;} delete2(, 1) delete2(, 0) next

74 list delete2(, 2) AnaAndrewCristinaJulianaMichael struct student *delete2(struct student *list, int index) { if(index == 0) { struct student *next = list->next; free(list); return next; }else { list->next = delete2(list->next, index-1); return list;} delete2(, 1) delete2(, 0) next

75 list delete2(, 2) AnaAndrewCristinaJulianaMichael struct student *delete2(struct student *list, int index) { if(index == 0) { struct student *next = list->next; free(list); return next; }else { list->next = delete2(list->next, index-1); return list;} delete2(, 1) delete2(, 0) next

76 list delete2(, 2) AnaAndrewCristinaJulianaMichael struct student *delete2(struct student *list, int index) { if(index == 0) { struct student *next = list->next; free(list); return next; }else { list->next = delete2(list->next, index-1); return list;} delete2(, 1) delete2(, 0) next

77 list delete2(, 2) AnaAndrewJulianaMichael struct student *delete2(struct student *list, int index) { if(index == 0) { struct student *next = list->next; free(list); return next; }else { list->next = delete2(list->next, index-1); return list;} delete2(, 1) delete2(, 0) next

78 list delete2(, 2) AnaAndrewJulianaMichael struct student *delete2(struct student *list, int index) { if(index == 0) { struct student *next = list->next; free(list); return next; }else { list->next = delete2(list->next, index-1); return list;} delete2(, 1) next

79 Questions?

80 Using malloc to create variable size arrays….

Download ppt "Pointers 2 COP3275 – PROGRAMMING USING C DIEGO J. RIVERA-GUTIERREZ."

Similar presentations

Dynamic Allocation and Linked Lists. Dynamic memory allocation in C C uses the functions malloc() and free() to implement dynamic allocation. malloc is.

Dynamic Allocation and Linked Lists. Dynamic memory allocation in C C uses the functions malloc() and free() to implement dynamic allocation. malloc is.
SEE C GO Provisional Title. Syntax Types int, float, double, char, void Identifiers foo Operators + - * / ^ Delimiters ; {} () “” ‘’ Keywords return,

SEE C GO Provisional Title. Syntax Types int, float, double, char, void Identifiers foo Operators + - * / ^ Delimiters ; {} () “” ‘’ Keywords return,
An introduction to pointers in c

An introduction to pointers in c
CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.

CSC 270 – Survey of Programming Languages C Lecture 6 – Pointers and Dynamic Arrays Modified from Dr. Siegfried.
David Notkin Autumn 2009 CSE303 Lecture 13 This space for rent.

David Notkin Autumn 2009 CSE303 Lecture 13 This space for rent.
Unions The storage referenced by a union variable can hold data of different types subject to the restriction that at any one time, the storage holds data.

Unions The storage referenced by a union variable can hold data of different types subject to the restriction that at any one time, the storage holds data.
Module R2 CS450. Next Week R1 is due next Friday ▫Bring manuals in a binder - make sure to have a cover page with group number, module, and date. You.

Module R2 CS450. Next Week R1 is due next Friday ▫Bring manuals in a binder - make sure to have a cover page with group number, module, and date. You.
Pointer applications. Arrays and pointers Name of an array is a pointer constant to the first element whose value cannot be changed Address and name refer.

Pointer applications. Arrays and pointers Name of an array is a pointer constant to the first element whose value cannot be changed Address and name refer.
CS113 Introduction to C Instructor: Ioannis A. Vetsikas Lecture 7 : September 8.

CS113 Introduction to C Instructor: Ioannis A. Vetsikas Lecture 7 : September 8.
Kernighan/Ritchie: Kelley/Pohl:

Kernighan/Ritchie: Kelley/Pohl:
Memory allocation CSE 2451 Matt Boggus. sizeof The sizeof unary operator will return the number of bytes reserved for a variable or data type. Determine:

Memory allocation CSE 2451 Matt Boggus. sizeof The sizeof unary operator will return the number of bytes reserved for a variable or data type. Determine:
Pointers Typedef Pointer Arithmetic Pointers and Arrays.

Pointers Typedef Pointer Arithmetic Pointers and Arrays.
1 Pointers A pointer variable holds an address We may add or subtract an integer to get a different address. Adding an integer k to a pointer p with base.

1 Pointers A pointer variable holds an address We may add or subtract an integer to get a different address. Adding an integer k to a pointer p with base.
Dynamic Data Structures H&K Chapter 14 Instructor – Gokcen Cilingir Cpt S 121 (July 26, 2011) Washington State University.

Dynamic Data Structures H&K Chapter 14 Instructor – Gokcen Cilingir Cpt S 121 (July 26, 2011) Washington State University.
Memory Arrangement Memory is arrange in a sequence of addressable units (usually bytes) –sizeof( ) return the number of units it takes to store a type.

Memory Arrangement Memory is arrange in a sequence of addressable units (usually bytes) –sizeof( ) return the number of units it takes to store a type.
Linked Lists Chained nodes of information create what are called linked lists, with each node providing a link to the next node. A useful feature of linked.

Linked Lists Chained nodes of information create what are called linked lists, with each node providing a link to the next node. A useful feature of linked.
CS 61C L4 Structs (1) A Carle, Summer 2005 © UCB inst.eecs.berkeley.edu/~cs61c/su05 CS61C : Machine Structures Lecture #4: Strings & Structs 2005-06-23.

CS 61C L4 Structs (1) A Carle, Summer 2005 © UCB inst.eecs.berkeley.edu/~cs61c/su05 CS61C : Machine Structures Lecture #4: Strings & Structs
1 CS 201 Dynamic Data Structures Debzani Deb. 2 Run time memory layout When a program is loaded into memory, it is organized into four areas of memory.

1 CS 201 Dynamic Data Structures Debzani Deb. 2 Run time memory layout When a program is loaded into memory, it is organized into four areas of memory.
Adapted from Dr. Craig Chase, The University of Texas at Austin.

Adapted from Dr. Craig Chase, The University of Texas at Austin.
Pointers Applications

Pointers Applications

Similar presentations

Ads by Google