Automatics, Copy Constructor, and Assignment Operator Andy Wang Object Oriented Programming in C++ COP 3330

Automatic Functions In C++, some default functions are automatically built Constructor // if you don’t provide one Destructor // if you don’t provide one Copy Constructor Assignment operator=

Copy Constructor Just like a constructor Examples Invoked implicitly when a COPY of an existing object is created; in particular, when An object is defined to have the value of another object of the same type An object is passed by value into function An object is returned (by value) from a function Examples Fraction f1, f2(3,4); Fraction f3 = f2; // a copy of f2 is created to initialize f3 f1 = f2; // calls the assignment operator, since f1 and f2 // already exist

Declaring and Defining A copy constructor creates a new object, initialized as a copy of another existing object Always has one parameter of the same type Passed by reference Since passing by value will invoke a copy constructor Format className(const className &); The const is not required, but a good idea for protecting the original Example Fraction(const Fraction &f);

Shallow vs. Deep Copy The default version makes a shallow copy Each member data location is copied Sufficient for classes like Fraction Only has a private numerator and denominator May not be sufficient for pointer member data Example: Phonebook The entryList pointer will be copied and will point to the original dynamically allocated memory

Deep Copy Creates a copy of dynamically allocated memory Directory::Directory(const Directory &d) { maxsize = d.maxsize; currentsize = d.currentsize; entryList = new Entry[d.maxsize]; for (int j = 0; j < currentsize; j++) entryList[j] = d.entryList[j]; }

Visualize the Execution stack (high address) int main() { … main heap (low address)

Visualize the Execution stack (high address) int main() { Directory d; … main int maxSize = 5 int curentSize = 0 Entry *entryList = d Entry[5] heap (low address)

Shallow Copy stack (high address) int main() { Directory d; Directory d2 = d; main int maxSize = 5 int curentSize = 0 Entry *entryList = d int maxSize = 5 int curentSize = 0 Entry *entryList = Entry[5] heap (low address)

Deep Copy stack (high address) int main() { Directory d; Directory d2 = d; main int maxSize = 5 int curentSize = 0 Entry *entryList = d int maxSize = 5 int curentSize = 0 Entry *entryList = Entry[5] Entry[5] heap (low address)

Assignment Operator operator= is similar to the copy constructor Called when one object is assigned to another Fraction f1, f2; f1 = f2; Assignment operator also has to make a copy The default version makes a shallow copy A deep copy needs to be overloaded by the user

Copy Constructor vs. Assignment Operator Initializes a new object as a copy of an existing one Initialize data for the first time Has no return value Sets the current state of an object to that of another existing object May need to free up old dynamically allocated memory Returns the value that was assigned, to support a = b = c = 4; Must be a member function

Chained Assignments a = b = c = 4; Same as a = (b = (c = 4)); Thus, (c = 4) returns 4 by reference Need the ability to refer to an object from inside the object

The this pointer Inside a member function An object can access its own address using the this keyword To return the object itself by reference, return the target of the this pointer, or *this Like a copy constructor, operator= will take one parameter of the same object type Examples Directory &operator=(const Directory &); Fraction &operator=(const Fraction &);

Directory Operator= Implementation Directory &Directory::operator=(const Directory &d) { if (this == &d) return *this; // don’t self copy // if you don’t check this, this can self destruct… delete [] entryList; maxsize = d.maxsize; currentsize = d.currentsize; entryList = new Entry[d.maxsize]; for (int j = 0; j < currentsize; j++) entryList[j] = d.entryList[j]; return *this; }

Phonebook Example http://www.cs.fsu.edu/~myers/cop3330/examples/co pyconst/phonebook/

directory.h #include “entry.h” class Directory { public: … Directory(const Directory &); Directory& operator=(const Directory &); private: };

directory.cpp … Directory::Directory(const Directory &d) { maxsize = d.maxsize; currentsize = d.currentsize; entryList = new Entry[d.maxsize]; for (int j = 0; j < currentsize; j++) entryList[j] = d.entryList[j]; }

directory.cpp Directory &Directory::operator=(const Directory &d) { if (this == &d) return *this; // don’t self copy delete [] entryList; maxsize = d.maxsize; currentsize = d.currentsize; entryList = new Entry[d.maxsize]; for (int j = 0; j < currentsize; j++) entryList[j] = d.entryList[j]; return *this; } …

Fraction Example http://www.cs.fsu.edu/~myers/cop3330/examples/co pyconst/frac/ No need for copy constructor and operator= Fraction does not have dynamically allocated memory Automatic versions are sufficient with the use of shallow copies

frac.h class Fraction { public: … Fraction(const Fraction &f); Fraction &operator=(const Fraction &f); private: };

frac.cpp … Fraction::Fraction(const Fraction &f) { numerator = f.numerator; denominator = f.denominator; } Fraction &Fraction::operator=(const Fraction &f) { return *this;