Object Oriented Programming COP3330 / CGS5409
C++ Automatics Copy constructor () Assignment operator = Shallow copy vs. Deep copy DMA Review c-strings vs. concept of string class
Constructor Destructor Copy Constructor Assignment operator = if you do not explicitly define one in a class, a default version will automatically be built for you by the compiler
The automatic versions of the constructor and destructor don't do anything, but they will be there if you do not build them. The constructor you get is the "default constructor" -- no parameters The automatic versions of the Copy Constructor and the Assignment operator overload are similar to each other, and their default versions are always built in a standard way.
A copy constructor IS a constructor, so it is a function with the same name as the class and no return type (just like any constructor). However, it is invoked implicitly when something is done that causes a COPY of an existing object to be created. This happens when: An object is defined to have the value of another object of the same type An object is passed by value into a function An object is returned (by value) from a function
Here's an example of item #1 in the above list: Fraction f1, f2(3,4); // declaration of two //fractions Fraction f3 = f2; // declaration of f3 being // initialized as a copy of f2 Note: This last line of code calls the copy constructor, since the initialization is on the same line as the declaration of f3. Contrast this with the following: f1 = f2; // this uses the assignment // operator, since f1 and f2 already exist
Since the purpose of a copy constructor is to not only initialize the data in an object, but to initialize it as a copy of another existing object, the original object must be passed in as a parameter. So, a copy constructor always has one parameter, which is of the same type as the class itself. It is always passed by reference, as well (it has to be - - since to pass by value, we must invoke a copy constructor, and this is what we are defining!) Format: classname(const classname &);
The const is not required, but it is usally a good idea, because we only want to make a copy -- we don't want to change the original. Here are some examples of copy constructor declarations for classes we have seen: Fraction(const Fraction & f); Timer(const Timer & t); Directory(const Directory & d); Store(const Store & s);
The default version of the copy constructor (created by the compiler) makes what is known as a shallow copy. This simply means that the object is copied exactly as is -- each member data value is copied exactly over to the corresponding member data location in the new object. This is sufficient for many cases, but not for ALL cases.
Example: Fraction f1(3,4); This fraction object has a numerator of 3 and a denominator of 4. If this object is passed into a function by value, a copy will be made, and the new object's numerator will be 3, denominator 4. In this case, the shallow copy is sufficient.
Consider, however, the Directory class of the phone book example. The member data variables were currentsize and maxsize (both of type int), and a pointer, entrylist (of type Entry * ), which pointed to dynamically allocated data outside the actual object. This is the situation in which a shallow copy is not sufficient.! For instance, if the original object is storing the address 1024 in entrylist, the copy will also get the 1024, and therefore the copy will be pointing to the original dynamic data!
This will especially pose problems if, when the copy goes out of scope, it cleans up the dynamic data along with it. When there is a pointer (inside an object) that points to dynamic data, the shallow copy is not sufficient, because it does not copy the dynamic data, only the pointer. A deep copy is needed. The following slide is what we might write for a copy constructor definition in the Directory class (from the phonebook database example):
Directory::Directory(const Directory & d) // copies object 'd' into the new object being created (this one) { // copy the static variables normally maxsize = d.maxsize; currentsize = d.currentsize; // create a new dynamic array for the // new object's pointer entrylist = new Entry[d.maxsize]; // copy the dynamic data } for (int i = 0; i < currentsize; i++) entrylist[i] = d.entrylist[i];
The assignment operator = is similar to the copy constructor. It is called when one object is assigned to another. Example call: Fraction f1, f2; f1 = f2; // this call invokes the //assignment operator Like the copy constructor, the assignment operator has to make a copy of an object. The default version makes a shallow copy. If a deep copy is desired for assignments on a user-defined type (e.g. a class), then the assignment operator should be overloaded for the class. The task done by the assignment operator is very similar to that of a copy constructor, but there are a couple of differences.
The copy constructor is initializing a brand new object as a copy of an existing one. The new object's data is being initialized for the first time. An assignment operator sets an existing object's state to that of another existing object. In situations with dynamic allocation, this may mean that old dynamic space must be cleaned up first before the copy is made. Also, an assignment operator also returns the value that was assigned (the copy constructor has no return). Consider the case of integers. In the statement: a = b = c = 4; The first operation is (c = 4), and this operation returns the assigned value (4), so that the result can be used as an operand in the next assignment (b = 4). This value should be returned by reference when overloading = for objects. To return the object, we need to be able to refer to an object from inside the object itself.
From inside any member function, an object has access to its own address through a pointer called this, which is a keyword in C++. In an assignment operator, you must return the object itself (by reference), so you can return the target of the this pointer (which would be *this) Like the copy constructor, the original object needs to be passed in, so there will be one parameter (of the same type as the object itself). The parameter is the same as in the copy constructor. Declaration examples for a few classes: Directory& operator= (const Directory &); Fraction& operator=(const Fraction &); Timer& operator=(const Timer &); Circle& operator=(const Circle &);
Directory& Directory::operator=(const Directory & d); // copies object 'd' into the new object being created (this one) { if (this!= &d) // only copy if object passed is not this one { // since this is not a brand new object, we // should delete any information currently attached delete [] entrylist; } // similar to the copy constructor definition maxsize = d.maxsize; currentsize = d.currentsize; entrylist = new Entry[d.maxsize]; for (int i = 0; i < currentsize; i++) entrylist[i] = d.entrylist[i]; } return *this; // return the object itself (by reference)
http://www.cs.fsu.edu/~myers/savitch3c++/ch10/10-10,%20-11,%20-12/chapter%2011%20version/ This example shows a class called PFArrayD, which is declared in the file "pfarrayd.h" and defined in "pfarrayd.cpp". This class stores a list of values of type double -- the list is stored using a dynamically allocated array, so there is no size limit. There are tracking variables in the member data for keeping track of the allocated space and the used space. The class also has a copy constructor and assignment operator -- both of them to do the "deep copy". And of course the destructor cleans up the space. The file "10-12.cpp" contains a main program that demonstrates some of the class features.
http://www.cs.fsu.edu/~myers/savitch3c++/ch10/1 0-10,%20-11,%20-12/Chapter%2011%20Version/ In this particular example, once the capacity of the array is set (when the object is created), it becomes the upper limit of storage for the list. How to use the array resizing technique to add functionality to the class? Specifically, to be able to remove the boundary check in the addelement function, and have no upper limit on the size of the list of values. (This would entail writing a Grow function, or perhaps a more generic "Resize" function -- to allow the allocated space to vary -- then calling it from appropriate places).
http://www.cs.fsu.edu/~myers/deitel5c++/c h11/fig11_17_18/ This is similar to the previous example, involving dynamic allocation inside a class. It is used to build a safer array type -- the class in this one is called Array, and it stores a dynamically created integer array. Both use dynamic memory management, but they vary a little in specific implementation details.
http://www.cs.fsu.edu/~myers/deitel5c++/ch11/fig11_1 7_18/ Some highlights of this example: Dynamic creation of array in the constructor Copy constructor and assignment operator, for deep copy Operator overloads provided (equality comparisons and for I/O) Two subscript operators (the brackets [] ). Note: when bracket operators are provided, the programmer does have the option to provide TWO versions -- one that returns by reference, and one that returns by value or by const reference (and must be a const member function). The difference is that one will return an L-value (storage location that could be modified), and one will return only an R-value (a read-only value).