1 / 18

ECE 264 Object-Oriented Software Development

ECE 264 Object-Oriented Software Development. Instructor: Dr. Honggang Wang Fall 2012 Lecture 24: Pointers and Dynamic Allocation. Lecture outline. Announcements / reminders Contact your project groups—design due 11/19

quade
Download Presentation

ECE 264 Object-Oriented Software Development

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. ECE 264Object-Oriented Software Development Instructor: Dr. Honggang Wang Fall 2012 Lecture 24: Pointers and Dynamic Allocation

  2. Lecture outline • Announcements / reminders • Contact your project groups—design due 11/19 • Meeting with project group next Wednesday in my office (during the lab session) regarding your project questions and design • 2:00-2:15 pm meeting with group 1 • 2:15-2:30 pm meeting with group 2 • 2:30-2:45 pm meeting with group 3 • 2:45-3:00 pm meeting with group 4 • Exam 2: 11/12 • Lab 7 due Tuesday, 11/06 • Today • Review: pointers • Basic usage • Pointer arithmetic • Common problems • Continue with pointers • Dynamic memory allocation • Destructors ECE 264: Lecture 24

  3. Refresher on pointers • Allocators (malloc, new) return pointer to allocated space • Pointer: address of another object • We implicitly use these when we pass function arguments by reference in C++ • Can get address of existing object using & • Can get value of existing pointer using * • Pointer declaration: <base type>* <pointer name> • Base type determines how reference is interpreted • Be careful when declaring multiple pointers • Be sure to initialize pointer before use ECE 264: Lecture 24

  4. Refresher on pointers, pt. 2 • Can assign pointers to one another; e.g. int x, *xp, *ip; xp = &x; ip = xp; • Array/pointer duality • Array name is pointer to first element • Can dereference array name (*arr) • Can treat pointers like arrays (ptr[i]) • Can perform pointer arithmetic on both • If ptr and arr point to first element of same array • ptr + i = arr + i = address of element arr[i] • ptr++  moves pointer to next array element • arr++  illegal: can’t change array name ECE 264: Lecture 24

  5. Dynamic memory allocation • Up until now, allocated memory statically • Assumed we knew data size at compile time • What if data size is input-dependent and unknown until run time? • In C, dynamic memory allocation handled through mallocand free • In C++, we use newanddelete • Allocator (new) returns pointer to allocated space ECE 264: Lecture 24

  6. Allocation with new • In C, malloc()allocates space on heap • malloc(sizeof(int))allocates space for 1 integer • malloc(20*sizeof(int))allocates an array of 20 integers • Both calls return pointer to first byte of element • In C++, we use new • new intallocates space for 1 integer • new int[20] allocates an array of 20 integers • As with malloc(),newreturns pointer to first byte • Directly initialize with value in parentheses • e.g. new int(3) ECE 264: Lecture 24

  7. Example int *iPtr; iPtr = new int; // 4 bytes are allocated // iPtr points to 1st byte double *dPtr; dPtr = new double[20]; // 160 bytes allocated // dPtr points to 1st byte heap iPtr dPtr 4 bytes allocated for single int variable 160 bytes allocated for 20 double variables ECE 264: Lecture 24

  8. Dynamic allocation example int main() { int *iPtr, *jPtr, i; iPtr = new int; jPtr = new int(3); double *dPtr; dPtr = new double[6]; *iPtr = 7; cout << *iPtr << ',' << *jPtr << endl; for(i=0; i<6; i++) dPtr[i] = 5; for(i=0; i<6; i++) cout << (*dPtr)++ << ' '; cout << endl; for(i=0; i<6; i++) cout << dPtr[i] << ' '; return 0; } OUTPUT 7, 3 5 6 7 8 9 10 11 5 5 5 5 5 Why? ECE 264: Lecture 24

  9. Dynamically allocated objects • May want to dynamically allocate objects • Ex. array of Points where size is unknown at compile time Point *pointArray; int numPoints; cin << numPoints; pointArray = new Point[numPoints]; • Ex. linked list data structure—to add an element to the list, must allocate new element class linkedList { private: int elem; linkedList *next; public: void addElement(int i) ... } void linkedList::addElement(int i) { next = new linkedList(i); } ECE 264: Lecture 24

  10. Referencing objects through pointers • Recall: use dot operator (.) to reference members of object, e.g: Point p1; p1.setX(2); • With pointers, use -> linkedList *list1 = new linkedList; list1->addElement(2); ECE 264: Lecture 24

  11. Deallocation with delete • Space allocated using new should be freed • In C, we used free() • In C++, we use delete • You should only use delete to free memory allocated by new • Any other use will result in an error ECE 264: Lecture 24

  12. 100 delete example int *ptr; ptr = new int (100); ptr delete ptr; //free the memory ptr • delete frees space on heap ... • ... but ptr still points to same address! • Solution: assign freed pointers to NULL: • ptr = NULL; ? ECE 264: Lecture 24

  13. Example: delete with arrays double *dptr; const int SIZE = 10; dptr = new double[SIZE];//80 bytes for(int i=0; i<SIZE; ++i) cin >> dptr[i]; fun1(dptr, SIZE); // pass array to fun1 delete [] dptr; //free all 10 elements dptr = NULL; ECE 264: Lecture 24

  14. Example: Dynamically resizing an array • to resize this so that the array called list has space for 5 more numbers int * list = new int[size]; • Create an entirely new array of the appropriate type and of the new size. int * temp = new int[size + 5]; • Copy the data from the old array into the new array (keeping them in the same positions). This is easy with a for-loop. for (int i = 0; i < size; i++) temp[i] = list[i]; • Delete the old array -- you don't need it anymore! delete [] list; // this deletes the array pointed to by "list" • Change the pointer. You still want the array to be called "list" (its original name), so change the list pointer to the new address. list = temp; ECE 264: Lecture 24

  15. Example of pointer arguments void Swap(int *p1, int *p2); void main () { int x, y; cin >> x >> y; cout << x << " " << y << endl; Swap(&x,&y); // passes addresses of x and y explicitly cout << x << " " << y << endl; } void Swap(int *p1, int *p2) { int temp = *p1; *p1 = *p2; *p2 = temp; } ECE 264: Lecture 24

  16. Example of reference arguments void Swap(int &a, int &b); void main () { int x, y; cin >> x >> y; cout << x << " " << y << endl; Swap(x,y); // passes addresses of x and y implicitly cout << x << " " << y << endl; } void Swap(int &a, int &b) { int temp = a; a = b; b = temp; } ECE 264: Lecture 24

  17. More example void main () { int r, s = 5, t = 6; int *tp = &t; r = MyFunction(tp,s); cout << r << "," << s << "," << t << endl; r = MyFunction(&t,s); cout << r << "," << s << "," << t << endl; r = MyFunction(&s,*tp); cout << r << "," << s << "," << t << endl; } int MyFunction(int *p, int i) { *p = 3; i = 4; return i; } Output (r, s, t) 4, 5, 3 4, 5, 3 4, 3, 3 ECE 264: Lecture 24

  18. Final notes • Next time • Dynamic allocation code examples • Acknowledgements: this lecture borrows heavily from lecture slides provided with the following texts: • Deitel & Deitel, C++ How to Program, 8th ed. • Etter & Ingber, Engineering Problem Solving with C++, 2nd ed. ECE 264: Lecture 24

More Related