Destructors Copy Constructors Copy Assignment Operators Adapted from

Destructors, Copy Constructors & Copy Assignment Operators Adapted from Dr. Mary Eberlein

Non-Default Destructor When do you need it? • Memory is allocated in your constructor: use a destructor to delete it. • Otherwise: memory leaks

Copy Constructor & Copy Assignment Operator • Two ways to copy an object: • copy constructor: create a new object that's a copy of an existing object • copy assignment operator: set an existing object equal to another object • For existing Person object p: • Copy constructor: • Person p 2(p); // create new object p 2 using state of existing object p • Or equivalently: Person p 2 = p; • Copy assignment operator: • Person p 2 =. . . ; • p 2 = p; // p 2 is a Person object, and we want to set its state equal to that of p • If we don't define them in our classes, we get a default destructor, copy constructor and copy assignment operator. • When do we need to define our own? If an object has pointers or some other runtime allocation of a resource (e. g. , opening a file). • default copy constructor and assignment operator will do a shallow copy • default destructor will not deallocate memory allocated for an instance variable

Example class String { private: char* str; int length; public: String(const char* str = NULL); // constructor ~String(); String(const String&); // copy constructor // other member functions. . . };

Shallow Copy • Default assignment operator and copy constructor produce a shallow copy String s 1("hello"); String s 2 = s 1; // default copy constructor invoked s 1 s 2 str length 5 'h' 'e' 'l' 5 'o' ''

Default Destructor • Default destructor does not free the heap-allocated array that the str instance variable points to String* s 1 = new String("hello"); delete s 1; // default destructor results in memory leak s 1 str length 5 'h' 'e' 'l' 'o' ''

Example String: : String(const char *s) { length = strlen(s); str = new char[length+1]; strcpy(str, s); } String: : ~String() { delete [] str; } // copy assignment operator String& String: : operator =(const String &s){ // copy constructor if(this != &s) { delete[] str; String: : String(const String& old. Str){ length = s. length; length = old. Str. length; str = new char[length+1]; strcpy(str, s. str); strcpy(str, old. Str. str); } } return *this; }

Copy Constructor & Copy Assignment • To avoid implementing them, you can declare them to be private in your class. • For example if you don’t want an object to be copied at all. Log files, certain design patterns, etc. • Then if a client attempts to invoke them, they get a compile error. • The Rule of Three is a rule of thumb for C++: if your class needs to define any of copy constructor, assignment operator, destructor, then it needs all three of them.