ECE 449 OOP and Computer Simulation Lecture 08 Resource Management I

Transcription

1 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 1/69 ECE 449 OOP and Computer Simulation Lecture 08 Resource Management I Professor Jia Wang Department of Electrical and Computer Engineering Illinois Institute of Technology October 13, 2017

2 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 2/69 Outline Object Composition and Exception Object Composition Exceptions Resource Management Resource Acquisition Is Initialization (RAII) Design Your Own Vector Class Flexible Memory Management Member Functions Efficient Updates Copy Control

3 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 3/69 Reading Assignment This lecture: 4.1, 11 Next lecture: Project 4 Specification

4 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 4/69 Outline Object Composition and Exception Object Composition Exceptions Resource Management Resource Acquisition Is Initialization (RAII) Design Your Own Vector Class Flexible Memory Management Member Functions Efficient Updates Copy Control

5 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 5/69 Outline Object Composition and Exception Object Composition Exceptions Resource Management Resource Acquisition Is Initialization (RAII) Design Your Own Vector Class Flexible Memory Management Member Functions Efficient Updates Copy Control

6 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 6/69 Object Composition Object composition: the method to compose larger objects from smaller ones E.g. a netlist object is consisting of many net and gate objects. So far we have seen two ways to compose an object. If we care about values, use a data member of type T or a container whose elements are of type T. If we care about objects themselves, use a data member of type T * or a container whose elements are of type T *, with the objects on the heap. Composition means ownership. When the parent object is constructed, the objects it holds should be constructed. When the parent object is destroyed, the objects it holds should be destroyed.

7 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 7/69 Object Composition Association Association: objects may interact with each other E.g. a net object interacts with multiple pin objects to decide what signal it should take. Associations are almost always implemented as pointers. However, association does not imply ownership. Never delete the pointers to the pin objects in the member container connections_ of a net object. Object composition or association? There are cases where it is difficult to tell one from the other so we need GC. Otherwise, it is still preferable in C++ to distinguish the two because ownership and lifetime matter for predictable performance.

8 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 8/69 Object Lifetime Management Recall there are two ways for object composition. 1. Objects that are member variables of the parent object Managed by the compiler automatically. Constructed before ctor body and destroyed after dtor body. E.g. the std::string members in various classes. 2. Objects on the heap owned by the parent object Managed by programmers through the ctors/dtor of the parent object. E.g. the net and gate objects in netlist. We need to learn how the compiler handles 1. in order to write correct code for 2.

9 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 9/69 Automatic Lifetime Management for Member Variables Member variables are constructed before any ctor body. They are constructed in the order they appear in the class definition. Programmers may specify how the members are constructed using the initializer list. The compiler will default initialize all the members whose constructions are not specified by programmers. Member variables are destroyed automatically after the dtor body. In the reversed order they appear in the class definition.

10 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 10/69 Outline Object Composition and Exception Object Composition Exceptions Resource Management Resource Acquisition Is Initialization (RAII) Design Your Own Vector Class Flexible Memory Management Member Functions Efficient Updates Copy Control

11 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 11/69 Motivations How to handle errors in ctors? Ctors cannot return results. How to enforce error handling? So far we always use the returned result of a function to indicate errors. However, it is up to the users of the function to verify whether there is any error. Users have reasons to ignore results from functions. It is quite tedious to verify results from every function calls. The code becomes much less readable if most of lines are dealing with errors and trying to resolve them. So invariants may be broken eventually and your program crashes.

12 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 12/69 Exceptions date::date(int y, int m, int d) : year(y), month(m), day(d) { if (!valid()) { throw std::runtime_error("invalid date"); Assume valid is a member function of date that returns whether year/month/day is a valid calendar date. Instead of returning the result of valid from the ctor, we notify the C++ implementation of the error by throwing an exception. You can throw an object of any type. Though in practice, people design different class types for different reasons of errors.

13 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 13/69 Standard Exception Types date::date(int y, int m, int d) : year(y), month(m), day(d) { if (!valid()) { throw std::runtime_error("invalid date"); std::runtime_error is a class type from the standard header stdexcept indicating an error at runtime. Recall that std::runtime_error("invalid date") constructs a std::runtime_error object with the argument "Invalid date". There are other standard exception types. As introduced in the textbook They are used by the standard library. You can also use them for your own program.

14 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 14/69 Use Exceptions to Replace Returns class date { public: void set(int y, int m, int d);... ; // class date void date::set(int y, int m, int d) { year = y; month = m; day = d; if (!valid()) { throw std::runtime_error("invalid date"); Usually, execution flow only need to report errors by throwing exceptions, and doesn t need to handle them. The readability of the code is improved since people no longer need to filter out error handling code when trying to understand the usual functionality.

15 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 15/69 Exception Handling void some_function() { date someday(2017, 2, 29);... // usual business flow bool do_business() { try { // usual business flow some_function(); another_function(); catch (std::exception &e) { std::cerr << e.what() << std::endl; return false; return true; Though you are forced to handle exceptions in your program, you don t need to handle them immediately. Improve readability by NOT flooding usual business flows with error handling codes If an exception is not handled, the program will abort.

16 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 16/69 Exceptions vs. Returned Results An exception that is not handled will be propagated automatically to the caller. You have to do that manually for results from functions. If an exception is not handled beyond main, the C++ implementation will handle it by aborting your program. A debugger can be used to identify the place such exception is thrown. If a result from a function indicating an error is not handled, most likely there will be undefined behavior. The most effective way to handle exceptions is to have a try-catch construct only when you know how to recover from the exception. E.g. have only one try-catch in main The exceptions are handled in a centralized manner. Otherwise, there is no advantage over returned results. You may choose to NOT handle exceptions at all.

17 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 17/69 Exceptions vs. Assertions Sometimes, it is hard to tell whether a violation of some condition is a violation of precondition or an error. Is passing an invalid combination of year/month/day to the ctor of date a violation of precondition or an error? Common practice: who causes the violation? If it is caused by programmers, e.g. because of typos or misunderstandings of function preconditions, use assertions. If it is caused by issues beyond programmer s control, e.g. invalid user inputs or network failures, use exceptions. It is still a design decision so there is no definite answer. You need to make your own trade-offs. Assertions may be turned off, making all checks useless. Check conditions and throw exceptions may affect the performance. An example: how std::vector handles out-of-range indices? [] uses assertions. The member function at will throw an exception.

18 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 18/69 Object Composition and Exception What happens to the parent object if an exception is thrown by a member ctor? Be aware that it is possible that some members are constructed and some are not.

19 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 19/69 Outline Object Composition and Exception Object Composition Exceptions Resource Management Resource Acquisition Is Initialization (RAII) Design Your Own Vector Class Flexible Memory Management Member Functions Efficient Updates Copy Control

20 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 20/69 Resource Management Resources: things with limited availability Memory File handles Network connections Database connections etc. Management: release a resource promptly Only when the resource was acquired successfully. After all the usages of the resource.

21 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 21/69 Resource management seems to be easy. void some_function() { FILE *fp = fopen("input_file", "r");... // do something with the file fclose(fp); Consider file operations in C. The file handle is acquired by fopen and released by fclose. A typical code sandwich: acquire use release.

22 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 22/69 Resource management could become complicated. // C-style resource management void some_function() { FILE *fp = fopen("input_file", "r"); if (...) {... fclose(fp); return; for (...) { if (...) {... else {... fclose(fp); return; fclose(fp); When there are many returns, the programmer is responsible to make sure the resource is always released.

23 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 23/69 The previous programs are WRONG! void some_function() { FILE *fp = fopen("input_file", "r"); another_function(fp); fclose(fp); If another_function throws an exception, fclose(fp); won t be executed. There will be resource leakage. A function in the call stack may allow the program to recover from the exception. However, you won t be able to release the file handle fp. It s lost.

24 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 24/69 Thinking of try-catch? void some_function() { FILE *fp = NULL; try { fp = fopen("input_file", "r"); another_function(fp); fclose(fp); catch (...) { if (fp!= NULL) fclose(fp); I should use finally as in many other languages. Though in C++ we don t have it since we don t need it. Those languages eventually learned from C++ so that finally is not needed in many cases nowadays.

25 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 25/69 Too complicated! // similar to Java resource management prior to Java 1.7 void some_function() { FILE *fp_in = NULL; FILE *fp_out = NULL; try { fp_in = fopen("input_file", "r"); do_something(fp_in); if (...) { fclose(fp_in); return; fp_out = fopen("output_file", "w"); do_something_else(fp_in, fp_out); for (...) {... if (...) { fclose(fp_out); fclose(fp_in); return; another_function(fp_out); fclose(fp_out); fclose(fp_in); catch (...) { if (fp_in!= NULL) fclose(fp_in); if (fp_out!= NULL) fclose(fp_out); When there are many returns and many resources. I can t guarantee the correctness of the above code since it is too complicated.

26 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 26/69 Outline Object Composition and Exception Object Composition Exceptions Resource Management Resource Acquisition Is Initialization (RAII) Design Your Own Vector Class Flexible Memory Management Member Functions Efficient Updates Copy Control

27 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 27/69 Resource Acquisition Is Initialization (RAII) void some_function() { std::ifstream fin("input_file"); do_something(fin); if (...) return; // fin destroyed std::ofstream fout("output_file"); do_something_else(fin, fout); for (...) {... if (...) return; // both fin and fout destroyed another_function(fout); // both fin and fout destroyed C++ makes programmer s life much easier via RAII. Leverage object lifetime for resource management (as adopted by many other languages). Use object composition to manage multiple resources. A resource is acquired when the object is constructed. The resource is released when the object is destroyed. We don t need to release fin and fout explicitly at every exit. What about exceptions?

28 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 28/69 Stack Unwinding void some_function() { std::ifstream fin("input_file"); do_something(fin); if (...) return; // fin destroyed std::ofstream fout("output_file"); do_something_else(fin, fout); for (...) {... if (...) return; // both fin and fout destroyed another_function(fout); // both fin and fout destroyed Local objects will be destroyed automatically whenever the function returns. Stack Unwinding: even when the function exits due to an unhandled exception. Since dtors may be called during exception handling, they SHOULD NEVER throw exceptions.

29 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 29/69 Object Lifetime Management with Exception How to design my own class for resource management via RAII? Objects that are member variables of the parent object What if a member construction throws an exception? Objects on the heap owned by the parent object Programmers should provide the same guarantee as the compiler provides automatically for the member variables.

30 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 30/69 Automatic Lifetime Management for Member Variables with Exception Member variables are constructed before any ctor body. In the order they appear in the class definition. Member are destroyed automatically after the dtor body. In the reversed order they appear in the class definition. If a ctor fails, i.e. throws an exception, compiler guarantees that, All or None: either the parent object is constructed successfully or none of the members got constructed. What if a dtor fails? Dtors should never fail you should not throw exceptions out of dtors.

31 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 31/69 Example I: The Classes struct will_not_throw { will_not_throw() {std::cout << "ctor of will_not_throw" << std::endl; ~will_not_throw() {std::cout << "dtor of will_not_throw" << std::endl; ; // struct will_not_throw class ctor_throw { will_not_throw wnt_; public: ctor_throw() { std::cout << "ctor of ctor_throw" << std::endl; throw std::runtime_error("from ctor of ctor_throw"); ~ctor_throw() {std::cout << "dtor of ctor_throw" << std::endl; ; // class ctor_throw Member functions can be declared and defined at the same time.

32 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 32/69 Example I: Parent Object on the Stack void some_function() { ctor_throw ct; void some_caller() { try { some_function(); catch (std::exception &e) { std::cout << e.what() << std::endl; The output ctor of will_not_throw ctor of ctor_throw dtor of will_not_throw from ctor of ctor_throw When the ctor of the parent object fails, the members are destroyed automatically. The dtor of the parent object will not be called since the object has not been constructed this is exactly what resource management needs!

33 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 33/69 Example I: Parent Object on the Heap void another_function() { ctor_throw *pct = new ctor_throw; void another_caller() { try { another_function(); catch (std::exception &e) { std::cout << e.what() << std::endl; The output is the same as in the previous slide. No memory leakage: when the construction fails, the piece of allocated memory is returned to the heap automatically.

34 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 34/69 Example II: The Classes struct will_throw { will_throw() { std::cout << "ctor of will_throw" << std::endl; throw std::runtime_error("from ctor of will_throw"); ~will_throw() {std::cout << "dtor of will_throw" << std::endl; ; // struct will_throw class member_throw { will_not_throw wnt_; will_throw wt_; public: member_throw() {std::cout << "ctor of member_throw" << std::endl; ~member_throw() {std::cout << "dtor of member_throw" << std::endl; ; // class member_throw

35 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 35/69 Example II: The Output void some_function() { member_throw mt; void some_caller() { try { some_function(); catch (std::exception &e) { std::cout << e.what() << std::endl; The output ctor of will_not_throw ctor of will_throw dtor of will_not_throw from ctor of will_throw When the ctor of a member fails, the members that are already constructed will be destroyed automatically. The body of the ctor of the parent object won t be executed. Same output if the parent object is created on the heap.

36 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 36/69 Outline Object Composition and Exception Object Composition Exceptions Resource Management Resource Acquisition Is Initialization (RAII) Design Your Own Vector Class Flexible Memory Management Member Functions Efficient Updates Copy Control

37 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 37/69 The Vec Class Vec<int> empty; // empty vector Vec<int> ones(100, 1); // vector of s for (size_t i = 0; i < ones.size(); ++i) { ones[i] = i; // access elements using [] for (Vec<int>::iterator it = ones.begin(); it!= ones.end(); ++it) { // iterators std::cout << *it << std::endl; Let s design a class Vec to learn how std::vector works. As a good example of how resource management should be done in any language. We usually design a class by specifying its interface first. So we follow the usual way std::vector is used.

38 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 38/69 Outline Object Composition and Exception Object Composition Exceptions Resource Management Resource Acquisition Is Initialization (RAII) Design Your Own Vector Class Flexible Memory Management Member Functions Efficient Updates Copy Control

39 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 39/69 Class Design // vec.h template <class T> class Vec { public: typedef T value_type; Vec(); Vec(size_t n, const value_type &val); private: value_type *data_; size_t n_; size_t capacity_; ; // class Vec<T> The member capacity_ indicates the number of elements that can be held in data_. The member n_ indicates the number of elements that are currently in data_.

40 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 40/69 Flexible Memory Management We need to keep two kinds of things in the array data_. data_[0],..., data_[n_-1] are initialized objects of type value_type as the elements. data_[n_],..., data_[capacity_-1] are not objects but bytes on the heap in other words, they are uninitialized and need to be constructed into objects. That s also the class invariant. Clearly new/delete cannot be used. We need language features/library functions to Determine how many memory bytes are required to hold a given number of objects Allocate that many bytes from the heap, uninitialized Construct individual objects on the uninitialized memory Destroy individual objects to make memory uninitialized Deallocate (release to the heap) the uninitialized memory

41 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 41/69 Memory Allocation Interface // vec.h template <class T> class Vec {... private:... static value_type *allocate(size_t n); static void deallocate(value_type *p); ; // class Vec<T> allocate should return a pointer to a piece of uninitialized memory that can hold n value_type object. deallocate should release the uninitialized memory pointed by p to the heap. Member functions should be declared static if they don t depend on any object of the class but are conceptually part of the class. Like usual functions, there is no implicit object parameter. Like member functions, they can access private members.

42 Memory Allocation // within class Vec<T> static value_type allocate(size_t n) { size_t num_of_bytes = sizeof(value_type)*n; void *p = ::operator new[](num_of_bytes); return (value_type *)p; For template classes, all members should be implemented within the class. The expression sizeof(t) returns the number of bytes an object of the type T consumes. The function operator new[] is used to allocate memory from the heap. For the standard header new When success, it returns a pointer to the memory. Otherwise, it throws std::bad_alloc. :: is used to emphasize it is from the global namespace. operator new[] has no idea what is the type of the objects the pointer it returns is of type void *. We need to convert it to a pointer to value_type objects. However, the memory remains uninitialized. ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 42/69

43 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 43/69 Memory Deallocation static void deallocate(value_type *p) { if (p == NULL) return; ::operator delete[](p); operator delete[] is used to release memory to the heap. Similarly, there are two functions operator new and operator delete. Moreover, as you may guess, The expression new T will call operator new to acquire the memory and then constructs the object. The expression delete p will destroy the object pointed by p and then call operator delete to release the memory. They have the same functionality as malloc and free in C.

44 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 44/69 Memory Initialization Interface private:... static void uninitialized_fill(value_type *uninit_b, value_type *uninit_e, const value_type &val); static void uninitialized_copy(const value_type *from_b, const value_type *from_e, value_type *uninit_b); We follow the standard library to create two static member functions for initializing a piece of memory into objects. uninitialized_fill will fill the uninitialized memory within the range [uninit_b, uninit_e) with objects having a value of val. uninitialized_copy will copy the objects within the range [from_begin, from_end) to the uninitialized memory pointed by uninit_b. It is programmers responsibility to ensure that piece of memory can hold enough number of objects.

45 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 45/69 Placement new static void uninitialized_fill(value_type *uninit_b, value_type *uninit_e, const value_type &val) { for (; uninit_b!= uninit_e; ++uninit_b) { new (uninit_b) value_type(val); The placement new statement new (p) T(args); is used to construct an object of type T on a piece of memory pointed by p, using arguments args. If you feel it s confusing, here is how to memorize the syntax: first, T(args) means to construct an object of type T using args; then new (p) means the object should be at the memory pointed by p. What if one construction throws an exception? Then we have no idea how many objects are actually constructed. Therefore we won t be able to destroy them, potential resource leakage!

46 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 46/69 Exception Safety for uninitialized fill static void uninitialized_fill(value_type *uninit_b, value_type *uninit_e, const value_type &val) { value_type *init_b = uninit_b; try { for (; uninit_b!= uninit_e; ++uninit_b) { new (uninit_b) value_type(val); catch (...) { // catch all exceptions for (; init_b!= uninit_b; ++init_b) { init_b->~value_type(); // call dtor to destroy the object throw; // re-throw the exception Postcondition of uninitialized_fill: All or None All the objects are initialized if the function returns normally. If some construction throws, then the function will throw the same exception and no object is initialized.

47 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 47/69 Implement uninitialized copy static void uninitialized_copy(const value_type *from_b, const value_type *from_e, value_type *uninit_b) { value_type *init_b = uninit_b; try { for (; from_b!= from_e; ++from_b, ++uninit_b) { new (uninit_b) value_type(*from_b); catch (...) { // catch all exceptions for (; init_b!= uninit_b; ++init_b) { init_b->~value_type(); // call dtor to destroy the object throw; // re-throw the exception Postcondition of uninitialized_copy: All or None

48 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 48/69 Implement Constructors and Destructor Vec() : data_(null), n_(0), capacity_(0) { Vec(size_t n, const value_type &val) : data_(allocate(n)), n_(n), capacity_(n) { try { uninitialized_fill(data_, data_+n_, val); catch (...) { deallocate(data_); throw; Vec::~Vec() { for (size_t i = 0; i < n_; ++i) { data_[i].~value_type(); deallocate(data_); If a ctor fail, the dtor won t be called automatically, so we need to deallocate the memory. The dtor of value_type should not throw.

49 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 49/69 Outline Object Composition and Exception Object Composition Exceptions Resource Management Resource Acquisition Is Initialization (RAII) Design Your Own Vector Class Flexible Memory Management Member Functions Efficient Updates Copy Control

50 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 50/69 Iterators template <class T> class Vec { public:... typedef value_type *iterator; typedef const value_type *const_iterator;... ; // class Vec<T> As the elements are stored in an array, pointers can be used as iterators for our container Vec. const_iterator: need a pointer pointing to const objects Type of pointers pointing to const objects of type T: const T * or equivalently T const * Is T * const a valid type? Yes, that s a const pointer: the pointer cannot be changed, but the object it points to can be changed.

51 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 51/69 Member Functions template <class T> class Vec { public:... size_t size() const {return n_; iterator begin() {return data_; iterator end() {return data_+n_; const_iterator begin() const {return data_; const_iterator end() const {return data_+n_;... ; // class Vec<T> Be aware of const and non-const member functions

52 Operator and Operator Overloading // some source file for (size_t i = 0; i < ones.size(); ++i) { ones[i] = i; // access elements using [] // vec.h template <class T> class Vec { public:... value_type &operator[](size_t i) { assert(i < n_); return data_[i];... ; // class Vec<T> The operator [] need to be defined for Vec so that the expression ones[i] makes sense. Operator overloading: when evaluating the expression ones[i], the compiler will attempt to translate it into the function call ones.operator[](i). You define what [] means for Vec by providing that member function, though you won t be able to call it directly. ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 52/69

53 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 53/69 Constness and Operators template <class T> class Vec { public:... const value_type &operator[](size_t i) const { assert(i < n_); return data_[i];... ; // class Vec<T> You should also provide a const operator[] for use with const Vec objects.

54 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 54/69 Outline Object Composition and Exception Object Composition Exceptions Resource Management Resource Acquisition Is Initialization (RAII) Design Your Own Vector Class Flexible Memory Management Member Functions Efficient Updates Copy Control

55 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 55/69 The reserve Function template <class T> class Vec { public:... void reserve(size_t cap);... ; // class Vec<T> We can make push_back even more efficient if the user can give us some hints on the number of the elements. The member function reserve should allocate enough memory to hold at least cap objects.

56 Implement reserve void reserve(size_t cap) { if (cap <= capacity_) return; // nothing to do if there is enough memory // prepare new memory/objects value_type *p = allocate(cap); try { uninitialized_copy(data_, data_+n, p); catch (...) { deallocate(p); throw; // get rid of old objects/memory for (size_t i = 0; i < n_; ++i) { data_[i].~value_type(); deallocate(data_); // update members data_ = p; capacity_ = cap; ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 56/69

57 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 57/69 Implement push back and pop back void push_back(const value_type &val) { if (n_ == capacity_) { reserve(std::max(n_+1, n_*2)); new (data_+n_) value_type(val); ++n_; void pop_back() { assert(n_ > 0); data_[n_-1].~value_type(); --n_; Each time when the container is full (n_ == capacity_), we need to reserve more memory. It has been proved if the capacity is increased by a fixed portion, then on average push_back will take O(1) time. Let s double it every time. We don t need to worry about exceptions since if something goes wrong, the dtor of Vec will take care of the elements and the memory.

58 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 58/69 Outline Object Composition and Exception Object Composition Exceptions Resource Management Resource Acquisition Is Initialization (RAII) Design Your Own Vector Class Flexible Memory Management Member Functions Efficient Updates Copy Control

59 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 59/69 Copy and Assignment Vec<int> a(100, 0); Vec<int> b = a; // make a copy Vec<int> c; c = a; // assignment Copy: construct an object as a copy of the existing one For Vec, elements should be constructed as a copy of those from the right-hand side (RHS). Assignment: change an object into a desired value For Vec, current elements should be destroyed and then be constructed as a copy of those from RHS. Copy Assignment Before copy, the object doesn t exist. Before assignment, the object is initialized.

60 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 60/69 Anything wrong? void some_function() { Vec<int> a(100, 0); Vec<int> b = a; // make a copy Vec<int> c; c = a; // assignment The program will compile. The compiler will generate code to handle copy and assignment. What s your expectation of the compiler? It is very unlikely the compiler knows the elements are stored on the heap and are managed by using data_ and n_. The compiler will simply make a copy of/assign the members. Members of a, b, c will have the same value. a.data_ will then be deallocated three times in the dtors of a, b, and c when the function returns undefined behavior! We need to redefine copy and assignment into meaningful operations.

61 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 61/69 Copy Constructor template <class T> class Vec { public... Vec(const Vec<T> &rhs);... ; // class Vec<T> Copy ctor is a ctor that takes an object of the same type as the parameter. It is called automatically when there is a need for a copy. The parameter should be of a reference type. Otherwise passing the argument itself would require a copy, which is not defined yet. In most cases, the RHS object shouldn t be changed. Use a const reference for the parameter Use a reference if your class design requires you to do so (very rarely)

62 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 62/69 Implement Copy Constructor Vec(const Vec<T> &rhs) : data_(allocate(rhs.n_)), n_(rhs.n_), capacity_(rhs.n_) { try { uninitialized_copy(rhs.data_, rhs.data_+n, data_); catch (...) { deallocate(data_); throw; Protections are per class instead of per object. So it is possible to access the private members of rhs in the copy ctor.

63 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 63/69 Copy Constructor and Function Calls Vec<int> increment(vec<int> v) { for (size_t i = 0; i < v.size(); ++i) { ++v[i]; return v; void some_function() { Vec<int> zeros(100, 0); Vec<int> ones = increment(zeros); There are 3 places where a copy of the Vec object is made and the copy ctor is called. The argument zeros is copied into the parameter v. The parameter v is copied into the returned result, which is an Vec object w/o a name. The returned result is copied into ones.

64 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 64/69 Assignment Operator template <class T> class Vec { public... Vec<T> &operator=(const Vec<T> &rhs);... ; // class Vec<T> Assignment operator = can be overloaded. It is called automatically for assignment. The parameter could be of any type. We are interested in the RHS object being also a Vec<T> object. So there are 3 choices for the type of the parameter: Vec<T>, const Vec<T> &, Vec<T> &. Using Vec<T> & is rare. Let s start with const Vec<T> &. It s a common practice to require operator= to return the object itself. In order to support assignments like a=b=c=d So the return type must be a reference.

65 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 65/69 Implement Assignment Vec<T> &operator=(const Vec<T> &rhs) { if (this == &rhs) return *this; // nothing to do for self-assignment // prepare new memory/objects value_type *p = allocate(rhs.n_); try { uninitialized_copy(rhs_.data_, rhs_.data_+rhs_.n_, p); catch (...) { deallocate(p); throw; // get rid of old objects/memory for (size_t i = 0; i < n_; ++i) { data_[i].~value_type(); deallocate(data_); // update members data_ = p; n_ = capacity_ = rhs.n_; return *this;

66 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 66/69 Some Ideas on Assignment Roughly speaking, assignment is destruction plus copy construction. Is there a elegant way to call the dtor and the copy ctor in operator= so we don t need to repeat the code?

67 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 67/69 The swap Function template <class T> class Vec { public... void swap(vec<t> &rhs) { std::swap(data_, rhs.data_); std::swap(n_, rhs.n_); std::swap(capacity_, rhs.capacity_);... ; // class Vec<T> It s usually very easy to swap two objects of the same class type: just swap each member. We have seen using references to swap two integers. Actually you can use std::swap for the same purpose. The swap function is so simple that it won t throw.

68 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 68/69 Assignment as Copy-and-Swap Vec<T> &operator=(const Vec<T> &rhs) { if (this == &rhs) return *this; // nothing to do for self-assignment Vec<T> copy = rhs; swap(copy); return *this; We don t need to worry about failures due to exceptions in this function anymore. They are taken care of by ctors and dtor.

69 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 69/69 Summary and Advice Exceptions interact with objects in a complicated way. Stack unwinding: local objects are automatically destroyed even when there is an unhandled exceptions. All or None: either the parent object is constructed successfully or none of the members got constructed. The compiler will synthesize the following special member functions for all types: Default ctor if there is no user-defined ctor. Each of dtor, copy ctor, operator= if it is not defined by user. An synthesized function will propagate the semantics of the function to each data member. The rule of three: if a class owns a kind of resources, e.g. memory on the heap, then dtor, copy ctor, operator= should all be provided for proper resource management. Ctors are always necessary for types with non-trivial class invariants.