Implementing Abstractions

Size: px

Start display at page:

Download "Implementing Abstractions"

Norah Glenn
6 years ago
Views:

1 Implementing Abstractions

2 Pointers A pointer is a C++ variable that stores the address of an object. Given a pointer to an object, we can get back the original object. Can then read the object's value. Can then write the object's value. Think of a pointer as a URL for the object.

3 Pointers Setting up a pointer requires two steps: Declare the pointer variable. Initialize the pointer variable to refer to some object. These are all separate steps, and forgetting any one can result in hard-tofind bugs. Once the pointer is set up, we can use it to read and write the object it refers to.

4 Pointers, Visually int m = 137; int n = 42; int* ptr1 = &m; int* ptr2 = &n; *ptr1 = 2718; *ptr2 = *ptr1; ptr1 = ptr2; *ptr1 = m / n;

5 Pointers, Visually int m = 137; int n = 42; int* ptr1 = &m; int* ptr2 = &n; m n *ptr1 = 2718; *ptr2 = *ptr1; ptr1 = ptr2; *ptr1 = m / n;

6 Pointers, Visually int m = 137; int n = 42; int* ptr1 = &m; int* ptr2 = &n; m n *ptr1 = 2718; *ptr2 = *ptr1; ptr1 = ptr2; *ptr1 = m / n;

7 Pointers, Visually int m = 137; int n = 42; int* ptr1 = &m; int* ptr2 = &n; m n *ptr1 = 2718; *ptr2 = *ptr1; ptr1 = ptr2; *ptr1 = m / n; ptr1

8 Pointers, Visually int m = 137; int n = 42; int* ptr1 = &m; int* ptr2 = &n; m n *ptr1 = 2718; *ptr2 = *ptr1; ptr1 = ptr2; *ptr1 = m / n; ptr1

9 Pointers, Visually int m = 137; int n = 42; int* ptr1 = &m; int* ptr2 = &n; m n *ptr1 = 2718; *ptr2 = *ptr1; ptr1 = ptr2; *ptr1 = m / n; ptr1 ptr2

10 Pointers, Visually int m = 137; int n = 42; int* ptr1 = &m; int* ptr2 = &n; m n *ptr1 = 2718; *ptr2 = *ptr1; ptr1 = ptr2; *ptr1 = m / n; ptr1 ptr2

11 Pointers, Visually int m = 137; int n = 42; int* ptr1 = &m; int* ptr2 = &n; m n *ptr1 = 2718; *ptr2 = *ptr1; ptr1 = ptr2; *ptr1 = m / n; ptr1 ptr2

12 Pointers, Visually int m = 137; int n = 42; int* ptr1 = &m; int* ptr2 = &n; m n *ptr1 = 2718; *ptr2 = *ptr1; ptr1 = ptr2; *ptr1 = m / n; ptr1 ptr2

13 Pointers, Visually int m = 137; int n = 42; int* ptr1 = &m; int* ptr2 = &n; m n *ptr1 = 2718; *ptr2 = *ptr1; ptr1 = ptr2; *ptr1 = m / n; ptr1 ptr2

14 Pointers, Visually int m = 137; int n = 42; int* ptr1 = &m; int* ptr2 = &n; m n *ptr1 = 2718; *ptr2 = *ptr1; ptr1 = ptr2; *ptr1 = m / n; ptr1 ptr2

15 Pointers, Visually int m = 137; int n = 42; int* ptr1 = &m; int* ptr2 = &n; m n *ptr1 = 2718; *ptr2 = *ptr1; ptr1 = ptr2; *ptr1 = m / n; ptr1 ptr2

16 Pointers, Visually int m = 137; int n = 42; int* ptr1 = &m; int* ptr2 = &n; m n *ptr1 = 2718; *ptr2 = *ptr1; ptr1 = ptr2; *ptr1 = m / n; ptr1 ptr2

17 Pointers, Visually int m = 137; int n = 42; int* ptr1 = &m; int* ptr2 = &n; m n *ptr1 = 2718; *ptr2 = *ptr1; ptr1 = ptr2; *ptr1 = m / n; ptr1 ptr2

18 Pointers, Visually int m = 137; int n = 42; int* ptr1 = &m; int* ptr2 = &n; m n *ptr1 = 2718; *ptr2 = *ptr1; ptr1 = ptr2; *ptr1 = m / n; ptr1 ptr2

19 Pointers, Visually int m = 137; int n = 42; int* ptr1 = &m; int* ptr2 = &n; m n *ptr1 = 2718; *ptr2 = *ptr1; ptr1 = ptr2; *ptr1 = m / n; ptr1 ptr2

20 Pointers, Visually int m = 137; int n = 42; int* ptr1 = &m; int* ptr2 = &n; m n *ptr1 = 2718; *ptr2 = *ptr1; ptr1 = ptr2; *ptr1 = m / n; ptr1 ptr2

21 Pointers, Visually int m = 137; int n = 42; int* ptr1 = &m; int* ptr2 = &n; m n *ptr1 = 2718; *ptr2 = *ptr1; ptr1 = ptr2; *ptr1 = m / n; ptr1 ptr2

22 Pointers, Visually int m = 137; int n = 42; int* ptr1 = &m; int* ptr2 = &n; m n *ptr1 = 2718; *ptr2 = *ptr1; m = 160; 2 ptr1 = ptr2; *ptr1 = m / n; ptr1 ptr2

23 Pointers, Visually int m = 137; int n = 42; int* ptr1 = &m; int* ptr2 = &n; m n *ptr1 = 2718; *ptr2 = *ptr1; m = 160; 2 ptr1 = ptr2; *ptr1 = m / n; ptr1 ptr2

24 Pointers, Visually int m = 137; int n = 42; int* ptr1 = &m; int* ptr2 = &n; m n *ptr1 = 2718; *ptr2 = *ptr1; m = 160; 2 ptr1 = ptr2; ptr1 = ptr2; ptr1 ptr2

25 Pointers, Visually int m = 137; int n = 42; int* ptr1 = &m; int* ptr2 = &n; m n *ptr1 = 2718; *ptr2 = *ptr1; m = 160; 2 ptr1 = ptr2; ptr1 = ptr2; ptr1 ptr2

26 Pointers, Visually int m = 137; int n = 42; int* ptr1 = &m; int* ptr2 = &n; m n *ptr1 = 2718; *ptr2 = *ptr1; m = 160; 2 ptr1 = ptr2; ptr1 = ptr2; ptr1 ptr2 Assigning Assigning one one pointer pointer to to another another changes changes which which object object is is being being pointed pointed at. at. It It does does not not change change the the value value of of the the pointee. pointee.

27 Why would we ever want to do this?

28 Allocating Multiple Objects One of the most important applications of pointers is dynamic memory allocation, the ability to construct brand-new objects at runtime. To allocate an array of n objects of type T, use the syntax new T[n] This returns a pointer to the array of elements you have just allocated.

29 Dynamic Memory Allocation int* ptr; ptr = new int; *ptr = 137;

30 Dynamic Memory Allocation int* ptr; ptr = new int;? *ptr = 137; ptr

31 Dynamic Memory Allocation int* ptr; ptr = new int[5];? *ptr = 137; ptr

32 Dynamic Memory Allocation int* ptr; ptr = new int[5];? *ptr = 137; ptr???????????????

33 Dynamic Memory Allocation int* ptr; ptr = new int[5]; *ptr = 137; ptr???????????????

34 Dynamic Memory Allocation int* ptr; ptr = new int[5]; ptr[0] = 137; ptr???????????????

35 Dynamic Memory Allocation int* ptr; ptr = new int[5]; ptr[0] = 137; ptr 137????????????

36 Dynamic Memory Allocation int* ptr; ptr = new int[5]; ptr[0] = 137; ptr[2] = 42; ptr 137????????????

37 Dynamic Memory Allocation int* ptr; ptr = new int[5]; ptr[0] = 137; ptr[2] = 42; ptr 137??? 42??????

38 Notes on Dynamic Arrays Arrays in C++ do not know their own size. You must store this separately. Arrays in C++ do not have boundschecking. You must make sure not to read off the end of the array. Arrays in C++ cannot be resized.

39 Cleaning Up Unlike other languages like Java, in C++, you are responsible for deallocating any memory allocated with new[]. You can deallocate memory with the delete[] operator: delete[] ptr; This destroys the array pointed at by the given pointer, not the pointer itself.

40 Cleaning Up Unlike other languages like Java, in C++, you are responsible for deallocating any memory allocated with new[]. You can deallocate memory with the delete[] operator: delete[] ptr; This destroys the array pointed at by the given pointer, not the pointer itself. ptr

41 Cleaning Up Unlike other languages like Java, in C++, you are responsible for deallocating any memory allocated with new[]. You can deallocate memory with the delete[] operator: delete[] ptr; This destroys the array pointed at by the given pointer, not the pointer itself. ptr

42 Cleaning Up Unlike other languages like Java, in C++, you are responsible for deallocating any memory allocated with new[]. You can deallocate memory with the delete[] operator: delete[] ptr; This destroys the array pointed at by the given pointer, not the pointer itself. ptr???

43 Words of Caution C++ has few of the safety features present in Java. All of the following result in undefined behavior in C++: Reading or writing through a pointer that you haven't initialized. Reading or writing through a pointer to memory that you have deallocated. Reading off the end of an array. Treating a non-array like an array.

44 Implementing Stack

45 Implementing Stack Last time, we saw how to implement RandomBag in terms of Vector. We could also implement Stack in terms of Vector. What if we wanted to implement the Stack without relying on any other collections? Let's build the stack directly!

46 Storing Values Right now, if we need to store multiple values, we can Declare a whole bunch of variables, Use a collections class, or Dynamically allocate space.

47 Storing Values Right now, if we need to store multiple values, we can Declare a whole bunch of variables, Use a collections class, or Dynamically allocate space.

48 Storing Values Right now, if we need to store multiple values, we can Declare a whole bunch of variables, Use a collections class, or Dynamically allocate space.

49 An Initial Idea A bounded stack. Allocate a fixed-size array for elements. Add elements to the array when they're pushed. Remove elements from the array when they're popped. Report an error if we exceed the size of the array.

50 An Initial Idea element array allocated length logical length 4 0

51 An Initial Idea 137 element array allocated length logical length 4 1

52 An Initial Idea element array allocated length logical length 4 2

53 An Initial Idea element array allocated length logical length 4 3

54 An Initial Idea element array allocated length logical length 4 4

55 An Initial Idea element array allocated length logical length 4 3

56 An Initial Idea element array allocated length logical length 4 2

57 An Initial Idea element array allocated length logical length 4 3

58 An Initial Idea element array allocated length logical length 4 4

59 Let's Code it Up!

60 Constructors A constructor is a special member function used to set up the class before it is used. The constructor is automatically called when the object is created. Syntax: The constructor for a class named ClassName has signature ClassName(args);

61 Destructors A destructor is a special member function responsible for cleaning up an object's memory. Automatically called when a local variable goes out of scope. Automatically called if you delete a pointer to an object. Syntax: The constructor for a class named ClassName has signature ~ClassName();

In Java we have the keyword null, which is the value of an uninitialized reference type

+ More on Pointers + Null pointers In Java we have the keyword null, which is the value of an uninitialized reference type In C we sometimes use NULL, but its just a macro for the integer 0 Pointers are