Objects Managing a Resource

Transcription

1 Objects Managing a Resource 1

2 What is a Resource Respects Release/Acquire protocol files (open/close) memory allocation (allocate/free) locks (acquire/release). 2

3 What is a Resource Objects when constructed, sometime acquire a resource. If designed carefully - acquire resource otherwise (when unavone oidable) will acquire several resources When an object is destructed, its resources must be released. 3

4 Construction of objects 1. Allocating - Allocating enough memory to hold the object's state 2. Initialization - Initializing the internal state of the object. This involves 2 sub-steps: 1. Acquiring Resources - Acquiring the necessary resources which the object requires 2. Consistent state - Making sure that the initial state of the object is valid according to the class invariants 4

5 Construction of objects RTE allocates the needed memory and calls the constructor of the class. constructor is different from normal method invocation object does not exist until the construction is finished. do not access this of object in the constructor. do not throw exceptions from the constructor 5

6 destruction of the object when an object is constructed, resources are allocated: explicitly, by the object's constructor implicitly memory allocated to hold the object's state resources should be deallocated. programmer's responsibility of releasing the resources acquired by a process 6

7 destruction of the object Releasing resources - releasing all of the resources acquired by the object during the object's lifetime and construction. Releasing memory - releasing all the memory allocated for the object 7

8 Who destructs what? destructing an object is shared between the RTE and the programmer: programmer releases resources acquired by constructor or during the life time RTE is responsible to release the memory allocated to hold the state of the object. 8

9 How to destruct? object is implicitly destructed if object is allocated on stack. when the program exits the scope of this object, the RTE will destruct the object. object allocated on the heap is destructed explicitly, by the programmer use delete operator on a pointer to the object. 9

10 Destruction order RTE calls a special function of the objectdestructor. responsibility of the programmer to implement such a function, and release all resources acquired by the object during the object's lifetime. RTE releases memory used to hold the object's state from stack or heap 10

11 LifeCycle of an Object object is "born" after constructor successfully terminates. object "retired" after destructor successfully terminates. object is "alive following its construction and just before its destruction. object is valid only as long as the object is alive. 11

12 Shape Collection Example object that holds a collection of shapes. will not create new shapes on its own will receive previously constructed shapes to store build the class 12

13 13

14 C++ interface Shape is an interface as all its functions are pure virtual [=0] in declaration Pure virtual are functions that the compiler enforce us to implement. An interface in C++ is implemented by using regular inheritance (C++ multiple inheritance) /**... */ - special tokens recognized by doxygen for auto documentation 14

15 15

16 16

17 Remarks class Shape - is a forward declaration typedef is used to define new types Shapes is a type (just like int or any other class). common to replace long types to short std::vector<t> is a C++ template that holds a collection of type T. 17

18 Remarks add() is receiving const Shape* - Shapes is of type vector<shape*> => Shapes vector cannot directly hold pointers received by add function (parameter is const and vector is not const) shapes are cloned and stored in collection cant just be referenced by the collection. fits well with collection description 18

19 Implementation 19

20 Remarks assert(shape!= 0) - as Add receives a pointer it must check for nullity. check man assert shapes_.size() must be const 20

21 Memory leak class hold clones of Shapes - responsible for releasing clones upon object destruction. add appropriate dtor to ShapeCollection 21

22 22

23 Remarks iterator is a pointer to an item of type T (here Shape*). Dereferencing iterator returns Shape* Dereferencing again to access a public method/member (**T) 23

24 Remarks Destructors are declared virtual inheritance If no good reason - declare each method as virtual. *i=0 for educational reasons. 24

25 Memory Addresses Aliasing 25

26 What is the problem? shapes passed to byval is copied to s. no copy-ctor implementation default copy constructor performs a shallow copy of the object's state. shapes_ vector of shapes is copied. shapes on the heap pointed twice: from shapes, and from s!!! 26

27 What is the problem? byval returns - destructor is called all the shapes of s are freed. shapes holds pointers to shape addresses in heap 27

28 Assignment (=) problem same problem arises with the assignment operator every Class is a type - supports assignment. given two ShapeCollections, s1 and s2: s1=s2 (s1=s1) exactly as you would do for int or double 28

29 Solution: copy define copy / assignment behavior possible behaviors are: 1. Do not allow one or both of them 2. Explicitly implement behavior which is consistent with the class design 29

30 empty behavior should be implemented with every class you write. if later you need copy or assignment - move to second solution. How? declare copy constructor and assignment operator as private! 30

31 copy-ctor called upon object construction syntax: given a const reference to another object of the same type (which you would not want to change) copy its state to this object state 31

32 Class(const Class& other) = ctor - copy behavior 32

33 Class(const Class& other) = ctor - copy behavior 33

34 Shapes::const_iterator an iterator to a const member of the Shapes vector. 34

35 assignment: operator= special method of the object syntax: given another object of the same type (which you would not want to change) copy its state to this object's state return an L-Value - meaning return the value of the left object. make sure an object is not assigned to itself 35

36 36

37 need to define such behaviors on classes someone will extend class in the future. inheritance techniques to reduce the overhead. 37

38 Managing Heap resource on Stack Recall: compiler calls ctor, dtor of objects declared on the stack automatically - when the scope is entered and exited when object is copied, the compiler calls the copy constructor. same for assignment (=) 38

39 Memory management class follow semantics of objects on the stack create generic class to hold object's pointer upon copy or assignment will not really copy the pointer but share it. count how many times the object is being referenced not delete it (when dtor is called) until the last reference is gone. 39

40 shared_ptr Boost - extension to the standard template library (STL), offering many advanced utilities use a shared_ptr when you have multiple pointers to the same pointee 40

41 41

42 On stack! 42

43 Remarks much shorter and cleaner. wrap the object of interest (shape*) - define a shared_ptr object on stack shared_ptr can then safely be given by value what we need, rather than the copy behavior 43

44 How does shared_ptr works? NO! copy or assignment behavior: Default: copy by val of all object's state. collection's state is shapes_ of type vector<shared_ptr<shape>> copy-ctor of vector is called vector holds a collection of objects - shared_ptr<shape> (shshape) 44

45 How does shared_ptr works? vector's copy-ctor copy by value shared_ptr copy-ctor shares pointer to actual shape on the heap shared_ptr holds a pointer and manages the reference count of this pointer shared_ptr copy-ctor and =operator - copy pointer by value manage the reference counting, with destructor 45

46 How does shared_ptr works? shared_ptr<t>t1 assigned to shared_ptr<t>t2 the pointer managed by t1 is copied to t2, such that they now manage the same pointer. t1 and t2 share a counter to count how many shared_ptr s are managing the same pointer. copying the pointer and sharing the counter t2 increments the reference counter by one. 46

47 How does shared_ptr works? t1=t2 If t2 had a pointer prior to copy, this pointer's reference count is first decreased by one. 47

48 How does shared_ptr works? When the dtor of shared_ptr is called - reference count is decreased. If count reaches zero, pointer managed by shared_ptr is deleted. 48

49 Exceptions During Construction problem may arise during ctor - lead to an exception being thrown exception during construction - object in an undetermined state. Re-implementing the new operator. master C++ 49

50 Exceptions During Construction Catching exceptions in ctor itself. two major problems: 1. construction needs to fail - no way of signaling this other than exception 2. can not handle out of memory exception inside ctor - thrown before ctor (by new) 50

51 Exceptions During Construction use the Factory design pattern; static method - in charge of initializing new objects return a pointer to a newly initialized object upon success or a null otherwise. 51

52 Factory Method any method whose main purpose is creation of objects. used to allow performing dangerous operation while creating an object example: memory allocation, accessing files, publishing the object address Factory Methods in Java for immutable objects. use of factory method has a wider scope 52

53 53

54 54

55 Arrays and Objects how to allocate arrays of primitive types in C++ each cell of the array is initialized using the default constructor. holds also for objects. 55

56 Each cell of the array is initialized twice! 1. the array is constructed, by using default ctor 2. using the assignment operator. total of 84! Shape objects created on stack 56

57 STL - containers Sequence containers: vectorvector (class template) dequedouble ended queue (class template) listlist (class template) Container adaptors: stacklifo stack (class template) queuefifo queue (class template) priority_queuepriority queue (class template) Associative containers: setset (class template) multisetmultiple-key set (class template) mapmap (class template) multimapmultiple-key map (class template) bitsetbitset (class template) 57

58 Sort void sort ( RandomAccessIterator first, RandomAccessIterator last ); void sort ( RandomAccessIterator first, RandomAccessIterator last, bool compare ); 58

59 Sort 59

60 Sort operator < 60

61 functor predicate specified can be a function pointer or a functor which is a class that defines operator() object when instantiated can be used just like a function would be. 61

62 62

63 STL - hash_map Hashed Associative Container - associates objects of type Key with objects of type Data. Pair Associative Container - value type is pair <const Key, Data> Unique Associative Container - no two elements have keys that compare equal using EqualKey. Looking up an element by key is efficient - useful for "dictionaries" where order is irrelevant 63

64 STL - hash_map 64

65 STL - hash_map Key - hash_map's key type Data - hash_map's data type. HashFcn - hash function used by the hash_map. EqualKey - hash_map key equality function a binary predicate that determines whether two keys are equal. 65