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 p2(p); // create new object p2 using state of existing object p Or equivalently: Person p2 = p; Copy assignment operator: Person p2 = ...; p2 = p; // p2 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 run- time 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 s1("hello"); String s2 = s1; // default copy constructor invoked s1 s2 str length str length 5 5 'h' 'e' 'l' 'o' '\0'

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

Example String::String(const char *s) { length = strlen(s); str = new char[length+1]; strcpy(str, s); } // copy constructor String::String(const String& oldStr){ length = oldStr.length; strcpy(str, oldStr.str); String::~String() { delete [] str; } // copy assignment operator String& String::operator =(const String &s){ if(this != &s) { delete[] str; length = s.length; str = new char[length+1]; strcpy(str, s.str); return *this; Make sure assignment operator works if we do something like this: x = x; (That's why we include the if) Return a reference to this object so that chaining of assignments works: x = y = z;

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.