10.5.4. Overriding The Copy Constructor

Three common operations cause a C++ program to copy an object:

• assignment
• passing an object to a function by value
• returning an object from a function by value

The operations are necessary and frequently occur in C++ programs, so the compiler automatically provides two object-copying functions: an assignment operator and a copy constructor. (We'll see how to implement the assignment operator as a function in the next chapter.) The compiler-created functions are sufficient in many but not all cases. Programmers must override both functions when the compiler-created versions are insufficient. The following guidelines, based on our earlier definitions of "simple" and "complex" classes, clarify when the overrides are necessary:

Operations That Copy Objects

To understand which functions we need to override, we must first understand which C++ statements copy an object and which functions perform the operation. Spotting an object copy is generally easy, but identifying the copying function is not, as the following figure demonstrates.

void Person::f1(Person p3)	// pass by value
{
	...
}

Person Person::f2()		// return by value
{
	...
	return Person(...);
}

Person Person::f3()		// return by value
{
	Person temp(...);
		...
	return temp;
}

Person::Person(Person& p)		// copy constructor
{
	...
}




Person& Person::operator=(Person& p)	// assignment operator
{
	...
	return *this;
}
 
 
 
 

Person p1(p);

f1(p);

Person p2 = p;

p0 = p;

p0 = f2();

Person p4 = f2();

Person p5 = f3();

The Compiler-Created Copy Constructor

The compiler-created copy constructor is necessarily simple and general. Our first task is to understand what the copy constructor does and then explore how the compiler might implement it.

int id; int weight; double height;
(a)	(b)
Person::Person(Person& p) { id = p.id; weight = p.weight; height = p.height; }	Person::Person(Person& p) { memcpy(this, &p, sizeof(Person)); }
(c)	(d)

Overriding The Copy Constructor

The previous discussion of object ownership in aggregation relationships alluded to situations where two or more objects in a program share another object. While programmers can establish the sharing while copying a "complex" object, they generally intend the copy operation to produce two distinct and independent objects. Independence implies that once the copy operations are complete, programs can change either object without affecting the other. When the original object is "simple" (i.e., it doesn't have pointer members), the compiler-created copy constructor creates independent objects. However, programmers must override the compiler-created copy constructor to achieve independence when copying "complex" objects (with one or more pointer members).

string* name; int weight; double height;
(a)	(b)

Person::Person(Person& p) { name = new string(*p.name); weight = p.weight; height = p.height; }
(a)
Person::Person(Person& p) { memcpy(this, &p, sizeof(Person)); name = new string(*p.name); }
(b)	(c)

Downloadable Code Examples

Complete versions of both programs described above are available for download and study (formatted with tabs set at eight spaces):

1. An earlier version of this section specified a string as the first member, as illustrated here. The member-by-member copy always works because the string class overloads the assignment operator (highlighted). (The next chapter describes how programmers overload operators.) However, the memcpy version was problematic, working with some compilers but not others. C++ compilers can choose between various valid string class implementations. The success or failure of memcpy depends on how the compiler implements the string class, making the memcpy version of the copy constructor unreliable and non-portable.

   Class Specification	Member Copy	Unreliable Byte-Copy
   string name; int weight; double height;	Person::Person(Person& p) { name = p.name; weight = p.weight; height = p.height; }	person::person(person& p) { memcpy(this, &p, sizeof(person)); }