Upload
caitlin-swalwell
View
221
Download
0
Tags:
Embed Size (px)
Citation preview
1
Classes Provide Constructors
Mechanism to specify object creation Client can use objects similar to
native types
Constructor is member function with the same name as the class
Constructs values of the class type
Initializes data members
Frequently, allocates free store using new
2
Getting Correct Memory for the Task
“Where did I put that memory? I need more to get the job done.”
3
Built-in Operators new and delete
new allocates memory from free store
delete deal locates memory from free store
Constructors often use new
Destructors often use delete
4
Using new
Initializer list
Expressions used by the object's constructor orsingle value used for a native type
p = new int(9); //pointer to int //initialized to 9 p = new int[9]; //pointer to 9 // element int array
5
Using Constructors and Destructors
Constructors are more complicatedMay be overloaded and take
arguments
Constructor invokedAssociated type used in definition
Call-by-value used to pass value to a function
Neither can use return statements
Destructors implicitly invoked
6
Constructors & Destructors
Form //can have multiple constructors class_name (parameter list); class_name (); //can have only 1 destructor ~class_name ();
Constructorsinitialization storage allocation
conversions
Destructorsfinalization storage reclamation
7
Constructors and the use of new
Usually involve application of new new type-name optional-init-list
new operator returns a pointer to base address of created object
In the case of an array of objects, this is the address of its first element
8
Constructor Initialization (1 of 2)
class mod_int {public: mod_int(int i) { v = i % modulus; } void assign(int i) { v = i % modulus; } void print() const { cout << v << '\t'; } const static int modulus;private: int v;};
const int mod_int::modulus = 60;
9
Constructor Initialization (2 of 2)
int main(){ int seconds = 400; mod_int z(seconds); //mod_int(int)
cout << seconds << " seconds equals " << seconds / 60 << " minutes "; z.print(); cout << " seconds" << endl; return 0;}
10
Comments on the mod_int Program
Integer v is restricted in value to 0, 1, 2, ...modulus - 1
Programmer's responsibility to enforce this
mod_int::mod_int() is constructor Invoked when objects of type mod_int are
declared
Function of one argument
Requires expression assignment-compatible with int parameter to be passed to it
Creates and initializes declared variable
11
Other mod_int Declarations
mod_int a(0); // a.v = 0;mod_int b(61); // b.v = 1;
but not
mod_int a; // no parameter listmod_int c = 49; //construct mod_int(49) //and copy into c
12
The Default Constructor
Constructor requiring no arguments
Empty argument list or all arguments have default values
Special purpose of initializing arrays of objects of its class
13
Multiple Constructors
Convenient to overload constructor with several function declarations
If no constructor, then arrays of objects automatically allocated by system
If class has constructors but does not a default constructor, array allocation is syntactic error
14
Default Constructor with mod_int
mod_int() { v = 0; }
Possible to have the following declarationsmod_int s1, s2; //init private v = 0mod_int d[5]; //arrays initialized
Empty parameter list constructor is invoked
Could have one constructor serve as both general initializer and default constructor
inline mod_int::mod_int(int i = 0) { v = i % modulus; }
15
Conversion Constructors
Constructors of single parameter
Used automatically for conversion unless declared with the keyword explicit
Metal::Metal(Ore) provides code used to convert an Ore object to a Metal object
Printable program prints invisible characters with their ASCII designation
Code 07 (octal) is alarm or bel
16
Printable program (1 of 3)
// ASCII printable characters// conversion constructor used
class pr_char {public: pr_char(int i = 0) : c(i % 128) { } void print() const { cout << rep[c]; }private: int c; static const char* rep[128];};
17
Printable program (2 of 3)
const char* pr_char::rep[128] = { "nul", "soh", "stx", ····· // filled in with table of //ASCII characters "w", "x", "y", "z","{", "|", "}", "~", "del" };
18
Printable program (3 of 3)
int main(){ pr_char c; for (int i = 0; i < 128; ++i) { c = i; // or c = static_cast<pr_char>(i); c.print(); cout << endl; }}
19
A Stack Whose Size can Vary
20
Constructing A Dynamically Sized Stack
Constructor can allocate space from free store
ch_stack’s length initialized by constructor
ch_stack has hidden implementation detailData members placed in private access
region
Public interface provides ch_stack abstraction
Public member functions, such as push() and pop()
21
The Stack Functions
Accessor functions do not change ch_stack object, such as top_of() and empty()
Usual to make these const member functions
Mutator functions change ch_stack object, such as push() and pop()
Constructor member functionscreate and initialize ch_stackobjects
22
Constructor Initializer (1 of 2)
Special syntax for initializing sub-elements of objects with constructors
Initializers for class members in comma-separated list following constructor parameter list
Initialization replaces assignment
Individual members must be initializable as member-name (expression list)
23
Constructor Initializer (2 of 2)
When members are themselves classes with constructors, expression list is matched to appropriate constructor signature
When non-static member is either const or reference, this form of member initialization is required
24
ch_stack Constructors (1 of 2)
ch_stack::ch_stack() : max_len (100), top (EMPTY) { //default constructor s = new char[100]; assert(s);}
ch_stack::ch_stack(int size) : max_len (size), top(EMPTY){ //specific size request assert(size > 0); s = new char[size]; assert (s);}
25
ch_stack Constructors (2 of 2)
//domain transfer
ch_stack::ch_stack(int size, const char str[]) : max_len(size){ int i; assert (size > 0); s = new char[size]; assert(s); for (i=0; i < max_len && str[i]!=0; ++i) s[i] = str[i]; top = — —i;}
26
Classes With Destructors
Member function whose name is the same as class name preceded by a tilde
Called implicitlyWhen exiting block in
which object was declared
When delete operator called on pointer to object having destructor
When deleting a subobjectof an object
27
Using delete
Destructors usually involve delete delete expression delete [] expression
Pointer variable used in assignment from a new expression
Brackets used when allocation involves a bracketed expression
Array of objects are allocated off of free store
Destructors called on each object stored in array
28
Problems with delete
Deletion of zero-valued pointer is harmless
Multiple deletions of same object is error
System-dependent behavior results
Deletion of pointer value not gottenfrom new expression is an error
System-dependent behavior results
29
Destructor Details
Implicitly invoked when object out of scopeBlock and function exit
my_string sub_str(char c, string b){ //friend of my_string my_string substring; for (int i = 0; i <= b.len; ++i) if (c == s[i]) break; substring.assign(s + i); return substring;}
30
Comments on sub_str()
b is call-by-value argument of type my_stringCopy constructor invoked to create a local
copy
Destructor is called on function exit
substring constructed upon block entry and destructor invoked on block exit
Return argument constructed and passed back into calling environment
Whether corresponding destructor is invoked depends on scope of object
31
A Destructor for ch_stack
class ch_stack {public: . . . ~ch_stack() { delete [] s; } . . .};
32
Comments on ch_stack with Destructor
External class interface remains the same
Destructor invoked implicitly on block and function exit to clean up storage that is no longer accessible
Good programming practice
Programs execute with less memory
33
Using the Constructors
//default creates s[100]ch_stack data;
//creates N 100 element ch_stacksch_stack d[N]; //N is 100 elsewhere
//construct from my_string//w.s[0]='A'...w.s[3]='D' w.s[4] = 'A'ch_stack w(5, "ABCDA");
//constructs from existing ch_stackch_stack x(w);
34
The Copy Constructor and call-by-value
Examine ch_stack and count number of occurrences of a given character
Repeatedly pop ch_stack, testing each element
To preserve ch_stack, call-by-value int cnt_char(char c, ch_stack s)
{ int count = 0; while (!s.empty()) count += (c == s.pop()); return count;}
35
ch_stack and Copy Constructor
Original Copy During Originalch_stack of Original Pop
ch_stackch_stack Operations Preserved
36
The Default Copy Constructor
Call-by-value requires that local copy of argument type be created and initialized from value of expression passed as actual argument
Compiler provides a default copy constructor ch_stack::ch_stack(const ch_stack&);
Compiler copies by memberwise initialization
Default copy constructor may not work in all circumstances for complicated aggregates with members who are themselves pointers
37
Scope & Deletion in Copy Constructors
In many cases, pointer is address of object deleted when going out of scope
Duplicating pointer value but not object pointed at can lead to anomalous code
Deletion affects other instances that still expect object to exist
object
38
Making a Copy Constructor for ch_stack
ch_stack::ch_stack(const ch_stack& str): max_len(str.max_len),top(str.top){ s = new char[str.max_len]; assert(s); memcpy(s, str.s, max_len);}
39
Garbage Collection for Reclaiming Memory
list example shows system reclaiming memory by traversing each list and disposing of each element
Reclamation is a form of garbage collection
In LISP, Java, and C#, system itself is responsible for reclamation
Systems periodically invoke garbage collector to identify all cells currently accessible and reclaim remaining inaccessible cells
40
Cheshire Cat Data Hiding
Indirection provides data hiding
Use of separate class for underlying data representation
Cheshire Cat technique, in honor of Lewis Carroll’s cat that disappeared leaving only a smile
This is a Design Pattern
41
Cheshire Cat Version of ch_stack
class ch_stack {public: void reset() { ptr -> reset(); } void push(char c) { ptr->push(c); } char pop() { return ptr->pop(); } char top_of() const { return ptr->top_of(); } bool empty() const { return ptr -> empty(); } bool full() const { return ptr -> full(); }private: ch_stk_rep* ptr; // opaque pointer};
42
Cheshire Cat Comments
All data and underlying operations handled through ch_stk pointer
ch_stack is known as wrapper class
Relationship between wrapper class and underlying representation class is called handle design pattern
43
Reference Counts
“Don’t shut me off,
fool, there are still 3
users attached!”
44
Reference Counting
Each object tracks its active references
On object creation, reference count set to one
When object newly referenced, reference count incremented
Each time object loses a reference, count decremented
Delete object when reference count is zero
45
Reference Counting Semantics
Underlying, frequently hidden, representation defined to include reference count
Wrapper publicly delivers objects and tracks reference count
Attention is paid to construction, destruction and assignment of object values
46
Reference Counted String Class (1 of 4)
#include <string.h> //check compiler#include <iostream.h>
class str_obj {public: int len, ref_cnt; char* s; str_obj() : len(0), ref_cnt(1) { s = new char[1]; s[0] = 0; } str_obj(const char* p) : ref_cnt(1) { len = strlen(p); s = new char[len + 1];strcpy(s, p); } ~str_obj() { delete []s; }};
47
Reference Counted String Class (2 of 4)
class my_string {public: my_string() { st = new str_obj; } my_string(const char* p) { st = new str_obj(p); } my_string(const my_string& str) { st = str.st; st -> ref_cnt++; } ~my_string(); void assign(const my_string& str); void print() const { cout << st -> s; }private: str_obj* st;};
48
Reference Counted String Class (3 of 4)
void my_string::assign(const my_string& str){ if (str.st != st) { if (--st -> ref_cnt == 0) delete st; st = str.st; st -> ref_cnt++; }}
This could be replaced by overloaded =
49
Reference Counted String Class (4 of 4)
my_string::~my_string(){ if (--st -> ref_cnt == 0) delete st;}
50
Comments on Reference Count (1 of 2)
Client uses objects of type my_stringObjects implemented as pointers st
to values of type str_obj
Copy constructor uses reference semantics
51
Comments on Reference Count (2 of 2)
Anytime object's reference count is decremented, test for deletion
Large aggregate copied by reference, with a small, fixed number of operations
Reference counter uses small storage
Change to pointer adds to reference count
Destructor must test reference count
52
Assign() Semantics
Semantics of assign() show subtleties
Assignment occurs if my_string not being assigned its same value
Assignment causes assigned variable to lose its previous value
Equivalent to decrementing reference count of pointed-at str_obj value
When reference count decremented, it gets tested for deletion
53
Advantages
Large aggregate is copied by reference, using few operations and small amount of storage for reference counter
Each possible change to pointer adds reference-count operation
54
Summary
Class constructors and destructors manage storage
Constructors can be used for copy and conversion
Code destructors to get rid of memory if you use new to create object
Reference counting semantics can help with large aggregates