Pointers: 2 Operators:

Transcription

1 Pointers: 2 Operators: & (address of operator) : returns the memory address of the first byte in memory of a variable * (dereference operator) : dereferences a variable (what is in or value pointed to by) int * ptr_to_int; // int variable // ptr_to_int is an address/location of an // same as int ptr_to_int, also known as what is // in/at the address/location of the // pointer ptr_to_int ptr_to_int = NULL; // initializes the new pointer variable to NULL ptr_to_int = new int; // Initializes the new pointer variable *ptr_to_int = 5; // in effect saying, what is in location pointer // ptr_to_int is now the integer 5 int x = 7; // creating a variable with value 7 in it ptr_to_int = &x; // the pointer ptr_to_int now has the location of //the variable x *ptr_to_int = 10; cout << x << endl; // ptr_to_int what it used to point to is now hanging in space // Need to use delete to free memory for future use. // Memory Leak int* ptr; *ptr = 100; // ptr has not been initialized // Either have to do int x = 100; ptr = &x; // or ptr = new int; *ptr = 100; Swap function using pass by reference. Swap function using pointers, swap takes two pointers Raw pointers the way we're doing it. If you get further into C++, it's generally not recommended that you use raw pointers. There is something called smart pointers.

2 Only delete what you new. int * ptr_to_int; ptr_to_int = new int; *ptr_to_int = 5; int x = 7; delete ptr_to_int; ptr_to_int = &x; Exercise: int a = 1; int b = 2; int c = 3; int *p; int *q; p = &a; q = &b; c = *p; p = q; *p = 13; p = &a; a = b + c; Pointers with Arrays: int nums[5]; int *p; p = nums; for(int i=0; i<5; i++) *(p+i) = i; // equivalent p[i] = i; // *(nums+i) = i; // or nums[i] = I; // If it's an array, it's name can be used as a pointer to its / first element Pointers to Pointers: int ** my_2d_array; Exercises: Linked Lists: What array looks like in memory:

3 Linked List uses Node and Pointer: Node: struct node int data; // pointer to the next node in the linked list struct node * next; ; First thing is to always make a head: node* head = new node; // Assign data to the head: (*head).data = 1; // can also be written head->data = 1; You will see this more often node* second = new node; second->data = 2; node* third = new node; third->data = 3; head->next = second; second->next = third; third->next = NULL; What does this look like in diagram form? There's your basic Linked List. Now we have to add functionality: void WrongPush(node* head, int data) newnode->next = head; // Doesn't work! Head is a local variable! void Push(node** headref, int data) // C implementation

4 newnode->next = *headref; *headref = newnode; void Push(node*& head, int data) // C++ implementation newnode->next = head; // Three steps: Make new node and set data, link the next node, change the head pointer int main() node* head = new node; head->data = 8; head->next = NULL; Push(head, 1); // for C need to use Push(&head, 1) Push(head, 3); cout << Length(head) << endl; // calling length // Now some useful linked list functions: int Length(node* head) int length = 0; while(*current!= NULL) length++; return length; // Demonstrates Passing the Head pointer // Iterating over a list with a local pointer void AppendNode(node*& head, int data)

5 newnode->next = NULL; if(current == NULL) // locate the last node while (current->next!= NULL) current->next = newnode COPY LIST FUNCTION IN THE PDF Won't go over in class // Get Nth Data int GetNth(node* head, int index) // basically like a[index] for arrays int i = 0; while(i < index && current!= NULL) i++; if(current == NULL) cout << "Index Out of Bounds!" << endl; return -1; return current->data; //InsertNth function void InsertNth(node*& head, int index, int data) node* previous = head; newnode->next = NULL;

6 preious. int i=0; if(index == 0) // basically using push here newnode->next = head; while(i < index && current!= NULL) previous = current; i++; if(current==null && i==index) //insert at the end of the list current->next = newnode; if(current == NULL && i <index) cout << "Error: Index Out of Bounds!" << endl; preious->next = newnode; newnode->next = current; // Couple different ways to implement this, Don't need to track // SortedInsert Insert into the correct position, ascending order void SortedInsert(node*& head, int data) node* previous = head; newnode->next = NULL; if(head == NULL) // List is empty if(newnode->data <= head->data) // check to see if it needs to go to the head node newnode->next = head;

7 // Loop to find placement of data while(current!= NULL && current->data < newnode->data) previous = current; if (current == NULL) previous->next = newnode; previous->next = newnode; newnode->next = current; // returns the data value and removes the node int RemoveNth(node*& head, int index_to_remove) int dataval; int i=0; node* previous = head; if(head == NULL) cout << "Linked List is empty!" << endl; return -1; if(index_to_remove == 0) dataval = head->data; head = head->next; delete current; // Iterate to index of node to remove while(i < index_to_remove && current!= NULL) i++; prev = current;

8 if(current==null) cout << "Error! Index out of bounds!" << endl; if(i == index_to_remove) dataval = current->data; prev->next = current->next; delete current; cout << "Error! Index not found!" << endl; return dataval;