1. Edgardo Molina, 2012 1 CSC212 Data Structure - Section AB Lecture 8 Dynamic Classes and the Law of the Big Three Instructor: Edgardo Molina Department of Computer Science City College of New York

2. Edgardo Molina, 2012 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. Edgardo Molina, 2012 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. Edgardo Molina, 2012 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. Edgardo Molina, 2012 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. Edgardo Molina, 2012 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. Edgardo Molina, 2012 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. Edgardo Molina, 2012 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. Edgardo Molina, 2012 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. Edgardo Molina, 2012 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. Edgardo Molina, 2012 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. Edgardo Molina, 2012 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. Edgardo Molina, 2012 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. Edgardo Molina, 2012 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. Edgardo Molina, 2012 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. Edgardo Molina, 2012 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. Edgardo Molina, 2012 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. Edgardo Molina, 2012 18 The 2 nd part of the value semantics copy constructor

19. Edgardo Molina, 2012 19 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

20. Edgardo Molina, 2012 20 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

21. Edgardo Molina, 2012 21 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

22. Edgardo Molina, 2012 22 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);

23. Edgardo Molina, 2012 23 What’s missing? allocate dynamic memory via new, take care of the value semantics,....?

24. Edgardo Molina, 2012 24 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

25. Edgardo Molina, 2012 25 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 does this happen? Question: when does this happen? bag::~bag() { delete [ ] data; }

26. Edgardo Molina, 2012 26 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; }

27. Edgardo Molina, 2012 27 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.

28. Edgardo Molina, 2012 28 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

29. Edgardo Molina, 2012 29 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; }

30. Edgardo Molina, 2012 30 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; }

31. Edgardo Molina, 2012 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); 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

32. Edgardo Molina, 2012 32 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

33. Edgardo Molina, 2012 33 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

34. Edgardo Molina, 2012 34 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);

35. Edgardo Molina, 2012 35 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 Feb 29 (Wed)! p Next Class: Exam review p Mar 05 Monday: First Exam 9:00 – 10:40 am