1 / 52

CS204 – Advanced Programming Pointers and Linked Lists Part 1: Basics

CS204 – Advanced Programming Pointers and Linked Lists Part 1: Basics. Representation of Data. All data in a the computer’s memory is represented as a sequence of bits: Bit : unit of storage, represents the level of an electrical charge. Can be either 0 or 1. 0 1

graham-pittman
Download Presentation

CS204 – Advanced Programming Pointers and Linked Lists Part 1: Basics

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. CS204 – Advanced ProgrammingPointers and Linked ListsPart 1: Basics

  2. Representation of Data All data in a the computer’s memory is represented as a sequence of bits: Bit : unit of storage, represents the level of an electrical charge. Can be either 0 or 1. 0 1 Byte (a.k.a Octet): 8 bits make up a byte, and a character is one byte A byte can represent 256 (0…255) different symbols: 2726252423222120 0 0 0 0 0 0 00  0 //binary representation and corresponding integer values 0 0 0 0 0 0 0 1 1 0 0 0 0 0 010  2 0 0 0 0 0 01 1 3 ... 1111111 1 255 Word: typical data size used in computer • 32 bits on some old computers (maybe in use) • 64 bits on most current modern computers

  3. Hex Numbers Hexadecimal numbers: - Similar to binary coding. - Each `digit` can take values: 0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F corresponding to values in: 0 to 15 (0-9, A = 10, B=11, ... F=15) e.g. 2435af00  0 0 1 0 | 0 1 0 0 | _ _ _ _ | _ _ _ _| _ _ _ _ | _ _ _ _ | _ _ _ _ | _ _ _ _ Sometimeswritten as 0x2435af00

  4. Hex Numbers: ctd. Representation and rules of arithmetic is similar to decimal, but do not forget that the number base is 16. 0x2435AF00 + 1 = 0x2435AF01 0x2435AEFF + 1 = 0x2435AF00

  5. c0x2435af00 n 0x2435af01 Memory What happens when we define variables: char c = 'A';  int n = 5;  0x2435af00 0x2435af01 Code of 'A' . . . 01000001 00000000 00000000 00000000 00000101 c n Symbol table 5 in binary ... Memory

  6. Pointers A pointer is a variable to store an “address in computer memory” Thus it points to a memory location Purpose: • Basis for implementing linked data structures linked lists, trees, graphs... • Provide dynamic memory allocation, variable size arrays 01000001 00000101 0x2435af00 c n p ... Memory

  7. Overview There are a couple of things you can do with pointers: • Declare one: int * ptr; char * pchar; • Store a value in it: ptr = &counter; • Dereference one: cout << *ptr; (Access the value stored where the pointer points to) cout << (*ptr).Day(); cout << ptr->Day(); Now we will see them in detail.

  8. c A p what happens in memory Pointers: definition A pointer is defined as:type* pointer_variable; e.g. char * ptr; ptr_variable does not store a type value, but stores the address of a memory location that stores a type value char c = 'A';  char *p; char *q = NULL ? q You can never know where an unititialized pointer points (i.e. the address of the memory location that it keeps) “Null” is defined in standard header files to mean “nowhere” or ”nothing”. It is the initial value for a variable that does not point to anywhere. Normally this value is 0.

  9. c A p . . . what happens in memory 0x2435af00 Pointers: “address of” operator (&) You can store the address of another variable in a pointer variable: char c = 'A';  char * p; p = &c; This is not the main use of pointers (assigning an existing variable’s address), but is useful in explaining the concept of address storage. Actually stores the code of 'A' Meansaddress of c

  10. c A p . . . what happens in memory Pointers: dereferencing *pointer-variable derefence (or indirection) operator. It gives the content of memory location pointed by the pointer-variable char c = 'A';  char * p; p = &c; cout << *p; prints the value of memorylocationpointedbyp. that is A this is thesame of thevalue of regularvariablec. just like “cout << c” prints the value of the char variable 0x2435af00

  11. 17.5 Pointers: assignment A pointer can be assigned to another pointer of the same type. Assume we have done as before: double n; double * p; p = &n; *p = 17.5;// memory location pointed by p contains 17.5 Now you can assign p to another pointer variable: double *q; q = p;// q and p points to the same location in memory 17.5 p n q p n

  12. c0x2435af00 p 0x2435af01 Pointers: definition(what happens behind the scenes) char c = 'A';     char *p;  0x2435af00 0x2435af01 . . . A ? c p Symbol table . . . //a pointer uses 4 bytes of memory when you have 32-bit adresses Memory

  13. c0x2435af00 p 0x2435af01 Pointers: address of a variable(what happens behind the scenes) char c = 'A';     char *p;     p = &c; // p now points to c. . . . A 0x2435af00 Symbol table 0x2435af00 0x2435af01 Alternative and more meaningful view: . . . c A p Memory

  14. c0x2435af00 p 0x2435af01 Pointers: dereferencing(what happens behind the scenes) char c = 'A';     char *p; p = &c; // p now points to c.   *p = 'B'; //unchanged . . . A B 0x2435af00 0x2435af00 0x2435af01 Symbol table . . . Alternative and more meaningful view: c A B p Memory

  15. Some Remarks What happens if you try to assign a string/int/double expression to a pointer variable? • e.g. double *q; q = 123.45; :syntax error What happens if you try to access a memory location pointed by a pointer that is not initialized? • e.g. double *q; cout << *q << endl; :a run-time (application) error occurs What happens if you display the value of a pointer? • e.g. cout << q << endl; :it displays the value of q, which is the address where it points to.

  16. p ? p Dynamic memory allocation with new Dynamic memory allocation using new statement newtype • allocates enough memory from heap (a special part of memory reserved for dynamic allocation - will discuss later) to store a type value • also returns the address of this memory location • need to assign this address to a pointer variable for processing Example double *p;//a pointer for double type, but currently points nowhere p = new double;// memory is allocated to store a double value, but //currently not initialized. p now points to that location

  17. Pointers with user-defined types/classes You can have pointers for any type: • built-in or user-defined types, classes and structs • E.g. int, double, char, string, robot, dice, date, … You can dynamically allocate memory for any type; note that the class constructor is called automatically to construct the object: myClass * classPtr; classPtr = new myClass;

  18. Pointer to Class Members Date *p_date; //preferred naming - starts with p Date *p1 = new Date; //p1 Date *p2 = p1; //p2 Date tomorrow = *p1 + 1; //tomorrow int month = (*p1).Month(); //month int day = p1->Day(); //day 18/02/2014 19/02/2014 2 18 ptr-> is a shorthand for (*ptr). if ptr is a pointer to a struct or a class

  19. Dynamic memory allocation with new – Allocating Multiple Variables int *p1, *p2; new keyword dynamically allocates enough memory for a single int, and returns its address, which is stored in p1 p1 = new int; In general, the new keyword dynamically allocates enough memory for the following type and count. Pointer p2 points to the first element of the list. This is how we generate DYNAMIC ARRAYs. p2 = new int[4]; count type p2

  20. Allocation of multiple variables with new Assume that we want to hold a dynamic array to hold vacation dates of varying numbers: cin >> num_vacations; Date * vacations = new Date[num_vacations]; The allocated memory is a contiguous memory than can hold num_vacations dates. Notice that you can access it like an array (it does not change or advance vacations as a pointer; just computes an offset from where vacations points to): Date today; vacations[0]= today; Vacations[1]= today + 1;

  21. Allocation of multiple variables with new Similarly, we can have a pointer to a list of 100 integers: int * primenumbers = new int[100]; //This offset operation does not mess up the pointer primenumbers[0]=2; primenumbers[1]=3; cout << "First prime is " << primenumbers[0];

  22. Manipulation using pointers You can also manipulate such an array using pointer syntax. int * pa = new int[100]; pa[0] and *pa are the same things What about pa[1]? It is the same as *(pa+1) In general, ptr+x means, the xth memory location (of the type of ptr) in the memory after ptr. What about pa[500]? Try and see! Also try other values larger than 99!

  23. Pointers for Implementing Linked Data Structures

  24. Linked Lists Built-in Arrays:-too much or too little memory may be allocated - ease of use - direct access - inserting an element into a sorted array may require shifting all the elements - deleting an element requires shifting Vectors : - may be resized but inefficient (Tvectors)- still some space wasted - inserting an element into a sorted array may require shifting all the elements (also for deletion) Note: In CS201 until previous year Tapestry's Tvector class was being used instead of standart Vector class. Basically they are the same. You can use whatever you want.

  25. Linked Lists Linked lists:- dynamic memory allocation - insertion/deletion is cheap (no shifting) - more cumbersome to program with head

  26. Introduction to linked lists: definition Consider the following struct definition struct node //node is a user given name { string word; int num; node *next; // pointer for the next node }; node * p = new node; ? ? p ? word next num

  27. Reminder: structs: as data aggregatessee Tapestry Chp. 7 pp. 330- If you need multiple arrays with tied elements (e.g. grades[MAXCLASS_SIZE], names[MAXCLASS_SIZE]...) or in general, any “tied” data, you should consider using a data structure called struct: struct point { double x_coord; double y_coord; }; point p1, p2; p1.x_coord = 10.0; //access members using the dot notation p1.y_coord = 0.0; ... Very similar to classes - but no member functions. You should use structs rather than classes only when you want to use them as data aggregates, without any member function (you may have a constructor though, see the next slide).

  28. Structs with constructors If you define one or more constructors: struct point { double x; double y; //default constructor point::point() { x = 0; y = 0; } //constructor point::point(int x_coord, int y_coord) : x (x_coord), y (y_coord) { //nothing more to initialize } }; Instead of: point curve[100]; curve[0].x = 0; curve[0].y = 0; curve[1].x = 7; curve[1].y = 12; ... You can use: point curve[100]; curve[0] = point (0,0); curve[1] = point (7, 12); • General Remarks: • Ifnoconstructor is used, it is OK. • Ifyouwanttohave a constructorwithparameter, alsowrite a defaultconstructor • Ifthere is constructor, creating a struct (dynamicor normal) variableautomaticallycallsdefaultconstructor (e.g. curve has 100 elements, allare (0,0) whencreated)

  29. Introduction to linked lists: inserting a node Without a constructor:With a constructor: node *p; node * p; p = new node; p=new node(5,"Ali",NULL); p->num = 5; p->word = "Ali"; p->next = NULL 5 Ali p word next num

  30. Updated node struct with constructor In order to use the struct as in the previous slide, we need to add a constructor to it: struct node //node is a user given name { int num; string word; node *next; // pointer for the next node //default constructor; actually does not initialize //anything but should exist node::node() { } //constructor with 3 parameters node::node(int n, string w, node * p) : num(n),word(w),next(p) {}; };

  31. Introduction to linked lists: adding a new node How can you add another node that is pointed by p->link? node *p; p = new node(5,"Ali",NULL); node *q; q 5 Ali ? p word next num

  32. ? ? Introduction to linked lists node *p; p = new node; p = new node(5,"Ali",NULL); node *q; q = new node; q 5 Ali ? ? p word next num word next num

  33. Introduction to linked lists node *p, *q; p = new node; p = new node(5,"Ali",NULL); q = new node; q->num=8; //I can still access fields one by one q->word = "Veli"; q 5 Ali 8 Veli ? ? p word next num word next num

  34. Introduction to linked lists node *p, *q; p = new node; p->num = 5; p->word = "Ali"; p->next = NULL; q = new node; q->num=8; q->word = "Veli"; q->next = NULL; p->next = q; q 5 Ali 8 Veli ? p word next num word next num

  35. Linked Lists: Typical Functions Printing an existing list pointed by head: struct node {    int info;    node *next; . . . //constructors }; node *head, *ptr; //list is filled here... //head points to first node head ptr = head; while (ptr != NULL) { cout << ptr ->info << endl; ptr = ptr->next; } End of a linkedlistshouldpointto NULL

  36. Linked Lists: Typical Functions Adding a node to the end of the list: void Add2End(node * tail, int id) { node *nn = new node(id,NULL); tail->next = nn; //This added the new id to the end of the list, //but now tail also needs updating – how? //we could return the new tail from the function: node * Add2End(node * tail, int id) //and let the caller do the update //or we could make tail a reference parameter and update it here… //but we left it as it is right now } head tail

  37. Linked Lists: building //Modified from strlink.cpp in Tapestry code //TASK: Put contents of storage into a linked list, struct node {    int info;    node *next; }; int storage[] = {1,2,3,4}; node *head = NULL; node *temp = NULL; for (int k=0; k < 4; k++) { temp = new node(); temp->info = storage[k]; temp->next = head; head = temp; } What happens as a result of this code’s execution? Let's trace on the board

  38. Linked Lists: building Thecodes in thelast 3 slidesare in ptrfunc.cpp, but this file alsocontainssomefeaturesthatwehave not seen as of now. Please do not getconfused. // Modified from strlink.cpp in Tapestry code struct node {    int info;    node *next; node::node () {} node (const int & s, node * link) : info(s), next (link) {} }; int storage[] = {1,2,3,4}; node *head = NULL, *temp = NULL; for (int k=0; k < 4; k++) { temp = new node (storage[k], head); temp = new node(); temp->info = storage[k]; temp->next = head; head = temp; } You better use a constructor to insert data more compactly and in a less error-prone fashion – like this.

  39. Stack and HeapScope and LifetimeExtern and Static VariablesFreeing Memory Allocated by New

  40. Static vs. Dynamic Memory Allocation Automatic (ordinary) variables:Normal declaration of variables within a function (including main): e.g. ints, chars that you define by “int n;” , “char c;” etc.. • C++ allocates memory on the stack (a pool of memory cells) for automatic variables when a function begins, releases the space when the function completes. • The lifetime of an automatic variable is defined by its scope (the compound block in which the variable is defined). After the block finishes, the variable’s location is returned to memory. • A blockis any code fragment enclosed in an left curly brace, {, and a right curly brace, }. Dynamic variables:Allocated by the new operator, on the heap (a storage pool of available memory cells for dynamic allocation). E.g.p = new int[100]; • new returns the address of the first element allocated (this is generally assigned to a pointer variable) • System will return NULL if there is no more space in heap to be allocated. • Programmer should use delete to release space when it is no longer needed.  • The lifetime of a dynamic variable is until they are explicitly deleted

  41. Local Variables vs Global Variables • A blockis any code fragment enclosed in an left curly brace, {, and a right curly brace, }. • Variables are categorized as either localor globalsolely based on there they are declared: inside a block out outside all blocks. • Local variables are declared in a block. • Global variables are declared outside of all blocks. • The scope of a local variable is the block in which the variable is declared. • A global variable is not limited in scope. This type of variable is visible to every module in the project. • A commonly complained shortcoming of C++ is the exposure created by using global variables. • This situation is usually avoided by prohibiting the use of global variables and instead passing information between modules in the form of function/method parameters.

  42. Externvariables • We said that a global variable is visible to every module in the project • But this is not automatic; you cannot simply use a global variable defined in say student.cpp in another cpp (say classes.cpp) of the same project • There is a mechanism to reach a global variable declared in another cpp file; using extern variable. • The actual definition of the global variable remains as is • This is where the memory is allocated for that variable • In the cpp file that you will reach the global variable defined outside of this cpp • You have toredefine the same global variable with preceedingextern keyword. • In this way, you do not allocate a new memory location, but inform the compiler that the actual definition of the variable is outside of that cpp file. • See externdemo1.cpp and externdemo2.cpp

  43. Static variables Static Local Variables • A variant of the 'normal' local variable is the static local. When the keyword staticpreceeds to the variable declaration, the lifetime of the variablebecomes the entire execution of the program. • The compiler to preserve the value of the variable even when it goes out of scope. • When program execution reenters the block in which the variable is declared, the variable still has the value it had when execution last left that block. Static Global Variables • A variant of the 'normal' global variable is the static global. Static global variables are visible to all methods/functions in the module (i.e. .cpp or .h files) where the variable is declared, but not visible to any other modules in the project. This strategy greatly reduces the opportunities for logic errors in larger programs. By doing this sharing information within a module is still possible. As long as modules are kept small and manageable, this strategy is useful.

  44. Heap/Stack: usage overview Stack (also called as runtime stack) • All automatic (ordinary) variables use a special part of memory called theruntime stack • The stack is useful for storing context during function calls, which is performed automatically transparent to the programmer.  • When a function,say dothis, is called in another function, saydothat, the function dothat simply pushes all its local variables (its context) onto the stack before passing the control to dothis. When the function dothis is completed, control returns to dothatbut beforehand,dothat pops the context off the stack. Heap • The heap is basically rest of memory that the program has.  In that sense, it is often the largest segment in a program.    • Dynamic variables are allocated on the heap and memory allocated for them stays until explicitly freed (deleted). • The memory area used for static and global variable allocation is basically part of heap, but mostly the area used for dynamically allocated variables is separated from static/global • This is compiler dependant Seestackheapaddress.cpp

  45. Heap/Stack Where are pointer variables stored, stack or heap? Pointer variables (themselves), just like the normal built-in variables and objects (int, double, string, vector, etc.) also use up memory, but not from the heap • they use the run-time stack

  46. Pointers: Delete The statement to de-allocate a memory location and return to the heap is: deletePointerVariable; • the memory location pointed by PointerVariable is now returned back to the heap; • this area now may be reallocated with a new statement • careful: PointerVariable still points to the same location, but that location is no longer used. This may cause confusion, so it is a good idea to reset the pointer to NULL (zero) after deleting. e.g.p = NULL;

  47. Freeing allocated memory with delete Date *p1 = new Date(); p1 Date *p2 = p1; p2 ... delete p1;//We need to delete memory allocated with new delete p2; //Deleting (freeing) previously freed memory possibly //causes a crash or a corrupt program depending on the // compiler and platform 25/02/2013

  48. Pointers to variables on the stack Can we have a pointer to point a variable that is not dynamically allocated? - using the & (address of) operator - such variables are not allocated from heap! • that is why their addresses are not close to dynamically allocated variables int num; int *ptr; num=5; ptr = &num; //ptr contains the address of num; cout << *ptr << endl; What is output?

  49. Question int n; int * p_temp = &n; Do we need to delete p_temp? No. It points to a stack variable. What happens if we delete? Most likely a crash or corrupt program, depending on the compiler.

  50. Memory allocation with the new operatorPoints to be careful for Dice * MakeDie(int n) //return pointer to n sided object { Dice nSided(n); return &nSided; } Dice * cube = MakeDie (4); Dice * tetra = MakeDie (6); cout << cube->NumSides(); Warning message: address of local variable returned What is the problem here?

More Related