new
Suppose you begin with the following base class that uses dynamic memory allocation:
// Base Class Using DMA
class baseDMA
{
private:
char * label;
int rating;
public:
baseDMA(const char * l = "null", int r = 0);
baseDMA(const baseDMA & rs);
virtual ~baseDMA();
baseDMA & operator=(const baseDMA & rs);
...
};
The declaration contains the special methods that are required when constructors use new
: a destructor, a copy constructor, and an overloaded assignment operator.
Now suppose you derive a lackDMA
class from baseDMA
and that lackDMA
does not use new
or have other unusual design features that require special treatment:
// derived class without DMA
class lacksDMA :public baseDMA
{
private:
char color[40];
public:
...
};
Do you now have to define an explicit destructor, copy constructor, and assignment operator for the lackDMA
class? The answer is no.
First, consider the need for a destructor. If you don’t define one, the compiler defines a default destructor that does nothing. Actually, the default destructor for a derived class always does something; it calls the base-class destructor after executing its own code. Because the lackDMA
members, we assume, don’t require any special action, the default destructor is fine.
Next, consider the copy constructor. As you saw in Chapter 12, the default copy constructor does memberwise copying, which is inappropriate for dynamic memory allocation. However, memberwise copying is fine for the new lacksDMA
member. That leaves the matter of the inherited baseDMA
object. What you need to know is that memberwise copying uses the form of copying that is defined for the data type in question. So copying a long
to a long
is done using ordinary assignment. But copying a class member or an inherited class component is done using the copy constructor for that class. Thus, the default copy constructor for the lacksDMA
class uses the explicit baseDMA
copy constructor to copy the baseDMA
portion of a lacksDMA
object. So the default copy constructor is fine for the new lacksDMA
member, and it’s also fine for the inherited baseDMA
object.
Essentially the same situation holds for assignment. The default assignment operator for a class automatically uses the base-class assignment operator for the base-class component. So it, too, is fine.
These properties of inherited objects also hold true for class members that are themselves objects. For example, Chapter 10, “Objects and Classes,” implements the Stock
class by using a string
object to represent the company name. The standard string
class, like our String
example, uses dynamic memory allocation. Now you see why this wouldn’t create problems. The default Stock
copy constructor would use the string
copy constructor to copy the company
member of an object, the default Stock
assignment operator would use the string
assignment operator to assign the company
member of an object, and the Stock
destructor (default or otherwise) would automatically call the string
destructor.
18.118.140.204