1. @ Zhigang Zhu, 2002-2014 1 CSC212 Data Structure - Section FG Lecture 8 Dynamic Classes and the Law of the Big Three Instructor: Zhigang Zhu Department of Computer Science City College of New York

2. @ Zhigang Zhu, 2002-2014 2 Why Dynamic Classes p Limitation of our bag class p bag::CAPACITY constant determines the capacity of every bag p wasteful and hard to reuse p Solution: p provide control over size in running time, by p pointers and dynamic memory p => dynamic arrays p => dynamic classes

3. @ Zhigang Zhu, 2002-2014 3 Dynamic Classes New Features (Ch 4.3–4) p Pointers Member Variables p Dynamic Memory Allocation (where and how) p Value Semantics (what’s new?) p assignment operator overloading p your own copy constructor p Introducing Destructor p Conclusion: the Law of the Big Three

4. @ Zhigang Zhu, 2002-2014 4 Pointer Member Variable  The Static bag  The Dynamic bag // From bag1.h in Section 3.1 class bag { public: static const size_t CAPACITY = 20;... private: value_type data[CAPACITY]; size_type used; }; // From bag2.h in Section 4.3 class bag { public:... private: value_type *data; size_type used; size_type capacity; };

5. @ Zhigang Zhu, 2002-2014 5 Invariant of the Dynamic bag  the number of items is in the member variable used  The actual items are stored in a partially filled array. The array is a dynamic array, pointed to by the pointer variable data  The total size of the dynamic array is the member variable capacity p Invariant is about rules of implementation...

6. @ Zhigang Zhu, 2002-2014 6 Allocate Dynamic Memory: Where? p In p In Old Member Functions  constructor  constructor – how big is the initial capacity?  insert  insert – if bag is full, how many more?  +/+=  +/+= operators operators – how to combine two bags? pNew Member Functions  reserve  reserve – explicitly adjust the capacity pExample pconstructor with default size

7. @ Zhigang Zhu, 2002-2014 7 Allocate Dynamic Memory: How?  In constructor : p why initialize? p how? p default p specific size // From bag2.h in Section 4.3 class bag { public: static const size_t DEFAULT_CAPACITY = 20; bag(size_type init_cap = DEFAULT_CAPACITY);... private: value_type *data; size_type used; size_type capacity; }; // From implementation file bag2.cxx bag::bag(size_type init_cap) { data = new value_type[init_cap]; capacity = init_cap; used = 0; }

8. @ Zhigang Zhu, 2002-2014 8 Value Semantics p Assignment operator p y = x; p Copy constructor p bag y(x); // bag y = x; Automatic assignment operator and copy constructor p copy all the member variables (data, used, capacity) from object x to object y p but our days of easy contentment are done!

9. @ Zhigang Zhu, 2002-2014 9 Failure in auto assignment operator x bag x(4), y(5); x.insert(18); x.insert(19); y=x; x.insert(20); 40984 capacity used data y50964 ???? ????? [0] [1] [2] [3] [0] [1] [2] [3] [0] [1] [2] [3] [4] [0] [1] [2] [3] [4] Question: What will happen after executing lines 2 – 5?

10. @ Zhigang Zhu, 2002-2014 10 Failure in auto assignment operator x bag x(4), y(5); x.insert(18); x.insert(19); y=x; x.insert(20); 42984 capacity used data y50964 1819?? ????? [0] [1] [2] [3] [0] [1] [2] [3] [0] [1] [2] [3] [4] [0] [1] [2] [3] [4] Question: What will happen after executing lines 2 – 5?

11. @ Zhigang Zhu, 2002-2014 11 Failure in auto assignment operator x bag x(4), y(5); x.insert(18); x.insert(19); y=x; x.insert(20); 42984 capacity used data y42984 1819?? ????? [0] [1] [2] [3] [0] [1] [2] [3] [0] [1] [2] [3] [4] [0] [1] [2] [3] [4] Question: What will happen after executing lines 2 – 5? lost memory

12. @ Zhigang Zhu, 2002-2014 12 Failure in auto assignment operator x bag x(4), y(5); x.insert(18); x.insert(19); y=x; x.insert(20); 43984 capacity used data y42984 181920? ????? [0] [1] [2] [3] [0] [1] [2] [3] [0] [1] [2] [3] [4] [0] [1] [2] [3] [4] Consequence: Change to x’ array will also change y’s array lost memory

13. @ Zhigang Zhu, 2002-2014 13 If we want y to have its own dynamic array x bag x(4), y(5); x.insert(18); x.insert(19); y=x; x.insert(20); 42984 capacity used data y50964 1819?? ????? [0] [1] [2] [3] [0] [1] [2] [3] [0] [1] [2] [3] [4] [0] [1] [2] [3] [4]

14. @ Zhigang Zhu, 2002-2014 14 Dynamic memory allocation is needed x bag x(4), y(5); x.insert(18); x.insert(19); y=x; x.insert(20); 42984 capacity used data y42964 1819?? ????? [0] [1] [2] [3] [0] [1] [2] [3] [0] [1] [2] [3] [4] [0] [1] [2] [3] [4] Answer: overloading the assignment operator = memory de-allocated 1819??

15. @ Zhigang Zhu, 2002-2014 15 Dynamic memory allocation is needed x bag x(4), y(5); x.insert(18); x.insert(19); y=x; x.insert(20); 42984 capacity used data y42964 181920? ????? [0] [1] [2] [3] [0] [1] [2] [3] [0] [1] [2] [3] [4] [0] [1] [2] [3] [4] Answer: overloading the assignment operator = memory de-allocated 1819??

16. @ Zhigang Zhu, 2002-2014 16 Solution: overloading assignment operator p Your own assignment operator p C++ Requires the overloaded assignment operator to be a member function bag x, y ; // OR bag x(4), y(5); // OR.... y=x; // y.operator=(x); void bag::operator=(const bag& source) // Postcondition: The bag that activated this function has the same items and capacity as source A 5-minute Quiz: write your own implementation - turn in // From bag2.h in Section 4.3 class bag { public: static const size_t DEFAULT_CAPACITY = 20; bag(size_type init_cap = DEFAULT_CAPACITY);... private: value_type *data; size_type used; size_type capacity; }; // From implementation file bag2.cxx bag::bag(size_type init_cap) { data = new value_type[init_cap]; capacity = init_cap; used = 0; }

17. @ Zhigang Zhu, 2002-2014 17 Implementation of operator= p y = x; p y  *this p x  source void bag::operator =(const bag& source) // Library facilities used: algorithm { value_type *new_data; // Check for possible self-assignment: if (this == &source) return; // If needed, allocate an array with a different size: if (capacity != source.capacity) { new_data = new value_type[source.capacity]; delete [ ] data; // make sure all valid before delete!!! data = new_data; capacity = source.capacity; } // Copy the data from the source array: used = source.used; copy(source.data, source.data + used, data); }

18. @ Zhigang Zhu, 2002-2014 18 The 2 nd part of the value semantics copy constructor

19. @ Zhigang Zhu, 2002-2014 19 Break p Programming Assignment 2 Due October 1st (Wed)! p Assignment 3 is online, due Oct 15 (Wed) p Next Class: Exam review p Oct 06 Monday: First Exam 4:00 – 5:30 pm

20. @ Zhigang Zhu, 2002-2014 20 The 2 nd part of the value semantics copy constructor

21. @ Zhigang Zhu, 2002-2014 21 Auto Copy Constructor: shallow copy x bag x(4) bag y(x); x.insert(18); x.insert(19); 40984 capacity used data y40984 ???? [0] [1] [2] [3] [0] [1] [2] [3] The only difference with auto assignment is: y does not have its own data

22. @ Zhigang Zhu, 2002-2014 22 Failure in auto copy constructor x bag x(4); bag y(x); x.insert(18); x.insert(19); 42984 capacity used data y40984 1819?? [0] [1] [2] [3] [0] [1] [2] [3] change to x also changes y

23. @ Zhigang Zhu, 2002-2014 23 Deep copy: providing your own copy constructor p Questions on Implementation (homework!) p do you need to check self-copy p bag y(x); // never have bag y(y); p do you need to delete old bag? p Questions on Usage p 4 different ways that copy constructor is used bag::bag(const bag& source) // Postcondition: The bag that has been constructed has the same items and capacity as source

24. @ Zhigang Zhu, 2002-2014 24 Four common situations p Declaration bag y(x); bag y(x); p Declaration with Alternate Syntax bag y = x ; bag y = x ; p Returning an object from a function bag union(const bag& s1, const bag& s2); bag union(const bag& s1, const bag& s2); p Value parameter is an object void temp_bag_copy(bag clone); void temp_bag_copy(bag clone);

25. @ Zhigang Zhu, 2002-2014 25 What’s missing? allocate dynamic memory via new, take care of the value semantics,....?

26. @ Zhigang Zhu, 2002-2014 26 De-allocation of dynamic memory p Return an object’s dynamic memory to the heap when the object is no longer in use p Where and How? – Two ways p Take care of it yourself  delete dynamic data of an object after you’re done with it p let the program do it automatically p destructor

27. @ Zhigang Zhu, 2002-2014 27 Destructor p The primary purpose is to return an object’s dynamic memory to the heap, and to do other “cleanup” p Three unique features of the destructor p The name of the destructor is always ~ followed by the class name; p No parameters, no return values; p Activated automatically whenever an object becomes inaccessible Question: when this happens? Question: when this happens? bag::~bag() { delete [ ] data; }

28. @ Zhigang Zhu, 2002-2014 28 Destructor p Some common situations causing automatic destructor activation p Upon function return, objects as local variables destroyed; p Upon function return, objects as value parameters destroyed; p when an object is explicitly deleted Question: shall we put destructor in how-to-use-a- bag documentation? Question: shall we put destructor in how-to-use-a- bag documentation? bag::~bag() { delete [ ] data; }

29. @ Zhigang Zhu, 2002-2014 29 The Law of the Big Three p Using dynamic memory requires the following three things all together p a destructor p a copy constructor (and of course an ordinary one) p an overloaded assignment operator p In other words, the three functions come in a set – either you need to write all three yourself, or you can rely on the compiler-supplied automatic versions of all the three.

30. @ Zhigang Zhu, 2002-2014 30 What will happen if not? If we only have a constructor and a destructor, but do not provide a copy constructor and an overloaded assignment operator

31. @ Zhigang Zhu, 2002-2014 31 Importance of the Law of Big-3 bag *x, *y; x = new bag(4); y = new bag(5); x->insert(18); x->insert(19); *y = *x; delete x; y->insert(20); Question: What will happen after executing lines 1 – 8? // destructor bag::~bag() { delete [ ] data; } // constructor bag::bag(size_type init_cap) { data = new value_type[init_cap]; capacity = init_cap; used = 0; }

32. @ Zhigang Zhu, 2002-2014 32 Importance of the Law of Big-3 *x*x*x*x bag *x, *y; x = new bag(4); y = new bag(5); x->insert(18); x->insert(19); *y = *x; delete x; y->insert(20); 40984 capacity used data *y*y*y*y50964 ???? ????? [0] [1] [2] [3] [0] [1] [2] [3] [0] [1] [2] [3] [4] [0] [1] [2] [3] [4] allocate memory for objects (*x, *y) and their dynamic arrays // From implementation file bag2.cxx bag::bag(size_type init_cap) { data = new value_type[init_cap]; capacity = init_cap; used = 0; }

33. @ Zhigang Zhu, 2002-2014 33 Importance of the Law of Big-3 bag *x, *y; x = new bag(4); y = new bag(5); x->insert(18); x->insert(19); *y = *x; delete x; y->insert(20); 42984 capacity used data 50964 1819?? ????? [0] [1] [2] [3] [0] [1] [2] [3] [0] [1] [2] [3] [4] [0] [1] [2] [3] [4] Insert two items in the dynamic array of object *x *x*x*x*x *y*y*y*y

34. @ Zhigang Zhu, 2002-2014 34 Importance of the Law of Big-3 42984 capacity used data 42984 1819?? ????? [0] [1] [2] [3] [0] [1] [2] [3] [0] [1] [2] [3] [4] [0] [1] [2] [3] [4] automatic assignment only copies three variables (capacity, used and data) from *x to *y lost memory bag *x, *y; x = new bag(4); y = new bag(5); x->insert(18); x->insert(19); *y = *x; delete x; y->insert(20); *x*x*x*x *y*y*y*y

35. @ Zhigang Zhu, 2002-2014 35 Importance of the Law of Big-3 42984 ????? [0] [1] [2] [3] [4] [0] [1] [2] [3] [4] Deleting x will also delete the dynamic array of *x by calling the destructor dangling pointer lost memory bag *x, *y; x = new bag(4); y = new bag(5); x->insert(18); x->insert(19); *y = *x; delete x; y->insert(20); bag::~bag() { delete [ ] data; } *y*y*y*y

36. @ Zhigang Zhu, 2002-2014 36 Importance of the Law of Big-3 *y*y*y*y 42984 ????? [0] [1] [2] [3] [4] [0] [1] [2] [3] [4] Your program crashes: *y needs its own copy of data !!! dangling pointer lost memory bag *x, *y; x = new bag(4); y = new bag(5); x->insert(18); x->insert(19); *y = *x; delete x; y->insert(20);

37. @ Zhigang Zhu, 2002-2014 37 Reading and Programming Assignments p Putting pieces together p bag2.h, bag2.cxx both in textbook and online online p Self-test exercises p 16 - 23 p After-class reading (string) p Section 4.5, Self-Test 26- 32 (within exam scope) p Programming Assignment 2 Due Oct 01 (Wed)! p Assignment 3 is online, due Oct 15 (Wed) p Next Class: Exam review p Oct 06 Monday: First Exam 4:00 – 5:30 pm