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

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

3. 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

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

5. 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'

6. 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'

7. 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;

8. 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.