《C++ primer plus》第13章：类继承（5）

继承和动态内存分配

继承是怎样与动态内存分配（使用 new 和 delete ）进行互动的呢？例如，如果基类使用动态内存分配，并重新定义赋值和复制构造函数，这将怎样影响派生类的实现呢？这个问题的答案取决于派生类的属性。如果派生类也使用动态内存分配，那么就需要学习几个新的小技巧。下面来看看这两种情况。

第一种情况：派生类不使用 new

假设基类使用了动态内存分配：

// 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);
}

声明中包含了构造函数使用 new 时需要的特殊方法：析构函数、复制构造函数 和 重载赋值运算符。
现在，从 baseDNA 派生出 lackDMA 类，而后者不使用 new，也未包含其他一些不常用的、需要特殊处理的设计特性：

// derived class without DMA
class lacksDMA : public baseDMA{
private:
	char color[40];
public:
	..
};

是否需要为 lackDMA 类定义显式析构函数、复制构造函数和赋值运算符呢？不需要。
首先，来看是否需要析构函数。如果没有定义析构函数，编译器将定义一个不执行任何操作的默认析构函数。实际上，派生类的默认析构函数总是要进行一些操作：执行自身的代码后调用基类析构函数。因为我们假设lackDMA 成员不需要执行任何特殊操作，所以默认析构函数是合适的。

接着来看复制构造函数。第12章介绍过，默认复制构造函数执行成员复制，这对于动态内存分配来说是不合适的，但对于新的 lacksDMA 成员来说是合适的。因此只需要考虑继承的 baseDMA 对象。要知道，成员复制将更具数据类型采用相应的复制方式，因此，将long复制到long中是通过使用常规赋值完成的；但复制类成员或继承的类组件时，则是使用该类的复制构造函数完成的。所以，lacksDMA类的默认复制构造函数使用显式 baseDMA 复制构造函数使用显式 baseDMA 复制构造函数来复制 lacksDMA 对象的 baseDMA 部分。因此，默认复制构造函数对于新的 lacksDMA 成员来说是合适的，同时对于继承的 baseDMA 对象来说也是合适的。

对于赋值来说，也是如此。类的默认赋值运算符将自动使用基类的赋值运算符来对基类组件进行赋值。因此，默认赋值运算符也是合适的。

派生类对象的这些属性也适用于本身是对象的类成员。例如，第10章介绍过，实现 Stock 类时，可以使用 string 对象而不是 char 数组来存储公司名称。标准 string 类和本书前面创建的 String 类一样，也采用动态内存分配。现在，读者知道了为何这不会引发问题。Stock 的默认复制构造函数将使用 string 的复制构造函数来复制对象的 company 成员； Stock 的默认赋值运算符将使用 string 的赋值运算符给对象的 company 成员赋值；而 Stock 的析构函数（默认或其他析构函数）将自动调用 string 的析构函数。

第二种情况：派生类使用 new

假设派生类使用了new：

// derived class with DMA
class hasDMA : public baseDMA{
private:
	char * style;		// use new in constructors
public:
...
};

在这种情况下，必须为派生类定义显式析构函数、复制构造函数和赋值运算符。下面依次考虑这些方法。

派生类析构函数自动调用基类的析构函数，故其自身的职责是对派生类构造函数执行工作的进行清理。因此，hasDMA 析构函数必须释放指针 style 管理的内存，并依赖于 baseDMA 的析构函数来释放指针 label 管理的内存。

baseDMA::~baseDMA() {	// takes care of baseDMA stuff
	delete [] label;
}

hasDMA::~hasDMA(){		// takes care of hasDMA stuff
	delete [] style;
}

接下来看复制构造函数。BaseDMA 的复制构造函数遵循用于 char 数组的常规模式，即使用 strlen() 来获悉存储 C-风格字符串所需的空间、分配足够的内存（字符数加上存储空字符所需的1字节）并使用函数 strcpy() 将原始字符串复制到目的地：

baseDMA::baseDMA(const baseDMA & rs) {
	label = new char[std::strlen(rs.label) + 1];
	std::strcpy(label, rs.label);
	rating = rs.rating;
}

hasDMA 复制构造函数只能访问 hasDMA 的数据，因此它必须调用 baseDMA复制构造函数来处理共享的baseDMA 数据：

hasDMA::hasDMA(const hasDMA & hs) : baseDMA(hs){
	style = new char[std::strlen(hs.style) + 1 ];
	std::strcpy(style, hs.style);
}

需要注意的一点是，成员初始化列表将一个 hasDMA 引用传递给 baseDMA 构造函数。没有参数类型为 hasDMA 引用的 baseDMA 构造函数，也不需要这样的构造函数。因为复制构造函数 baseDMA 有一个 baseDMA 引用参数，而基类引用可以指向派生类型。因此，baseDMA 复制构造函数将使用 hasDMA 参数的 baseDMA 部分来构造新对象的 baseDMA 部分。

接下来看赋值运算符。BaseDMA 赋值运算符遵循下述常规模式：

baseDMA & baseDMA::operator=(const baseDMA & rs) {
	if (this == & rs){
		return *this;
	}
	delete [] label;
	label = new char[std::strlen(rs.label)+1];
	std::strcpy(label, rs.label);
	rating = rs.rating;
	return * this;
}

由于 hasDMA 也使用动态内存分配，所以它也需要一个显式赋值运算符。作为 hasDMA 的方法，它只能直接访问 hasDMA 的数据。然而，派生类的显式赋值运算符必须负责所有继承的 baseDMA 基类对象的赋值，可以通过显式调用基类赋值运算符来完成这项工作，如下所示：

hasDMA & hasDMA::operator=(const hasDMA & hs){
	if (this == &hs) {
		return *this;
	}
	baseDMA::operator=(hs);	// copy base portion
	delete [] style;						// prepare for new style
	style = new char[std::strlen(hs.style)+1];
	std::strcpy(style, hs.style);
	return *this;
}

下述语句看起来有点奇怪：

baseDMA::operator=(hs);		// copy base portion

但通过使用函数表示法，而不是运算符表示法，可以使用作用域解析运算符。实际上，该语句的含义如下：

*this = hs;	// use baseDMA::operator=()

当然，编译器将忽略注释，所以使用后面的代码时，编译器将使用 hasDMA::operator=()，从而形成递归调用，使用函数表示法使得赋值运算符被正确调用而不是形成递归。

总之，当基类和派生类都采用动态内存分配时，派生类的析构函数、复制构造函数、赋值运算符都必须使用相应的基类方法来处理基类元素。这种要求是通过三种不同的方式来满足的。对于析构函数，这是自动完成的；对于构造函数，这是通过在初始化成员列表中调用基类的复制构造函数来完成的；如果不这样做，将自动调用基类的默认构造函数。对于赋值运算符，这是通过使用作用域解析运算符显式地调用基类的赋值运算符来完成的。

使用动态内存分配和友元的继承示例

为演示这些有关继承和动态内存分配的概念，我们将刚才介绍过的 baseDMA、lacksDMA 和 hasDMA 类集成到一个示例中。下面的程序是这些类的头文件。除了前面介绍的内容外，这个头文件还包含一个友元函数，以说明派生类如何访问基类的友元。

// dma.h -- inheritance and dynamic memory allocation

#ifndef DMA_H_
#define DMA_H_

#include<iostream>


// 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);
    friend std::ostream & operator<<(std::ostream & os, const baseDMA & rs);
};


// derived class without DMA
// no destructor needed
// uses implicit copy constructor
// uses implicit assignment operator
class lacksDMA : public baseDMA {
private:
    enum { COL_LEN = 40};
    char color[COL_LEN];
public:
    lacksDMA(const char * c = "blank", const char * l = "null", int r = 0);
    lacksDMA(const char * c, const baseDMA & rs);
    friend std::ostream & operator<<(std::ostream & os, const lacksDMA & rs);
};


// derived class with DMA
class hasDMA : public baseDMA{
private:
    char * style;
public:
    hasDMA(const char * s = "none", const char * l = "null", int r = 0);
    hasDMA(const char * s, const baseDMA & rs);
    hasDMA(const hasDMA & hs);
    ~hasDMA();
    hasDMA & operator=(const hasDMA & rs);
    friend std::ostream & operator<<(std::ostream & os, const hasDMA & rs);
};

#endif

// dma.cpp -- dma class methods

#include"13.14_dma.h"
#include<cstring>
#include <ostream>

// baseDMA methods
baseDMA::baseDMA(const char * l, int r){
    label = new char[std::strlen(l)+1];
    std::strcpy(label, l);
    rating = r;
}

baseDMA::baseDMA(const baseDMA & rs){
    label = new char[std::strlen(rs.label)+1];
    std::strcpy(label, rs.label);
    rating = rs.rating;
}

baseDMA::~baseDMA(){
    delete [] label;
}

baseDMA & baseDMA::operator=(const baseDMA & rs){
    if(this==&rs){
        return *this;
    }
    delete[] label;
    label = new char[std::strlen(rs.label)+1];
    std::strcpy(label, rs.label);
    rating = rs.rating;
    return *this;
}


std::ostream & operator<<(std::ostream & os, const baseDMA & rs){
    os << "Label: " << rs.label << std::endl;
    os << "Rating: " << rs.rating << std::endl;
    return os;
}




// lacksDMA methods
lacksDMA::lacksDMA(const char * c, const char * l, int r) : baseDMA(l, r){
    std::strncpy(color, c, 39);
    color[39] = '\0';
}

lacksDMA::lacksDMA(const char * c, const baseDMA & rs) : baseDMA(rs){
    std::strncpy(color,c, COL_LEN - 1);
    color[COL_LEN-1] = '\0';
}

std::ostream & operator<<(std::ostream & os, const lacksDMA & ls){
    os << (const baseDMA &) ls;
    os << "Color: " << ls.color << std::endl;
    return os;
}


// hasDMA methods
hasDMA::hasDMA(const char * s, const char * l, int r) : baseDMA(l,r){
    style = new char[std::strlen(s) + 1];
    std::strcpy(style,s);
}

hasDMA::hasDMA(const char * s, const baseDMA & rs) : baseDMA(rs){
    style = new char[std::strlen(s) + 1];
    std::strcpy(style, s);
}

hasDMA::hasDMA(const hasDMA & hs) : baseDMA(hs){
    style = new char[std::strlen(hs.style)+1];
    std::strcpy(style,hs.style);
}

hasDMA::~hasDMA(){
    delete [] style;
}

hasDMA & hasDMA::operator=(const hasDMA & hs){
    if(this==&hs){
        return *this;
    }
    baseDMA::operator=(hs); // copy base portion
    delete [] style;
    style = new char[std::strlen(hs.style)+1];
    std::strcpy(style, hs.style);
    return *this;
}

std::ostream & operator<<(std::ostream & os, const hasDMA & hs){
    os << (const baseDMA &)hs;
    os << "Style: " << hs.style << std::endl;
    return os;
}

上面的程序需要注意的是派生类如何使用基类的友元。例如，考虑下面这个hasDMA类的友元：

friend std::ostream & operator<<(std::ostream & os, const hasDMA & rs);

作为 hasDMA 类的友元，该函数能够访问style 成员。但该函数不是baseDMA类的友元，那它如何访问成员 label 和 rating 呢？答案是使用 baseDMA 类的友元函数 operator<<()。下一个问题是，友元不是成员函数，所以不能使用作用域解析运算符来指出要使用哪个友元函数。这个问题的解决方法是使用强制类型转换，以便匹配原型时能够选择正确的函数。因此，代码将参数 const hasDMA & 转换成类型为 const baseDMA & 的参数：

std::ostream & operator<<(std::ostream & os, const hasDMA & hs){
	// type cast to match operator<<(ostream & , const baseDMA &)
	os << (const baseDMA & ) hs;
	os << "Style: " << hs.style << endl;
	return os;
}

下面的程序是一个测试类 baseDMA、lacksDMA 和 hasDMA 的小程序：

// usedma.cpp -- inheritance, friends, and DMA
// compile with dma.cpp

#include<iostream>
#include "13.14_dma.h"

int main(){
    using std::cout;
    using std::endl;

    baseDMA shirt("Protabelly", 8);
    lacksDMA balloon("red", "Blimpo", 4);
    hasDMA map("Mercator", "Buffalo Keys", 5);

    cout << "Displaying baseDMA object:\n";
    cout << shirt << endl;

    cout << "Displaying lacksDMA object:\n";
    cout << balloon << endl;

    cout << "Displaying hasDMA object:\n";
    cout << map << endl;

    lacksDMA balloon2(balloon);
    cout << "Result of lacksDMA copy: \n";
    cout << balloon2 << endl;

    hasDMA map2;
    map2 = map;
    cout << "Result of hasDMA assignment:\n";
    cout << map2 << endl;
    
    return 0;
}

类设计回顾

C++ 可用于解决各种类型的编程问题，但不能将类设计简化成带编号的例程。然而，有些常用的指导原则，下面复习并拓展前面的讨论，以介绍这些原则。

编译器生成的成员函数

1. 默认构造函数

   默认构造函数要么没有参数，要么所有参数都有默认值。如果没有定义任何构造函数，编译器将定义默认构造函数，让您能够创建对象。例如，假设 Star 是一个类，则下述代码需要使用默认构造函数：

   Star rigel;		// create an object without explicit initialization
   Star pleiades[6];	// create an array of objects
   

   自动生成的默认构造函数的另一项功能是，调用基类的默认构造函数以及调用本身是对象的成员所属类的默认构造函数。

   另外，如果派生类构造函数的成员初始化列表中没有显式调用基类构造函数，则编译器将使用基类的默认构造函数来构造派生类对象的基类部分。在这种情况下，如果基类没有默认构造函数，将导致编译阶段错误。

   如果定义了某种构造函数，编译器将不会定义默认构造函数。在这种情况下，如果需要默认构造函数，则必须自己提供。

   提供构造函数的动机之一是确保对象总能被正确地初始化。另外，如果类包含指针成员，则必须初始化这些成员。因此，最好提供一个显式默认构造函数，将所有的类数据成员都初始化为合理的值。

2. 复制构造函数

   复制构造函数接受其所属类的对象作为参数。例如，Star 类的复制构造函数的原型如下：
   Star(const Star & )；

   在下述情况下，将使用复制构造函数：

   • 将新对象初始化为一个同类对象；
   • 按值将对象传递给函数；
   • 函数按值返回对象；
   • 编译器生成临时对象。

   如果程序没有使用（显式或隐式）复制构造函数，编译器将提供原型，但不提供函数定义；否则，程序将定义一个执行成员初始化的复制构造函数。也就是说，新对象的每个成员都被初始化为原始对象相应成员的值。如果成员为类对象，则初始化该成员时，将使用相应类的复制构造函数。

   在某些情况下，成员初始化是不合适的。例如，使用 new 初始化的成员指针通常要求执行深复制，或者类可能包含需要修改的静态变量。在上述情况下，需要定义自己的复制构造函数。

3. 赋值运算符
   默认的赋值运算符用于处理同类对象之间的赋值。不要将赋值与初始化混淆了。如果语句创建新的对象，则使用初始化；如果语句修改已有对象的值，则是赋值：

   Star sirius;
   Star alpha = sirius;		// initialization (one notation)
   Star dogstar;
   dogstar = sirius;			// assignment
   

   默认赋值为成员赋值。如果成员为类对象，则默认成员赋值将使用相应类的赋值运算符。如果需要显式定义复制构造函数，则基于相同的原因，也需要显式定义赋值运算符。Star 类的赋值运算符的原型如下：

   Star & Star::operator=(const Star &);
   

   赋值运算符函数返回一个 Star 对象引用。baseDMA 类演示了一个典型的显式赋值运算符函数示例。
   编译器不会生成将一种类型赋给另一种类型的赋值运算符。如果希望能够将字符串赋给 Star 对象，则方法之一是显式定义下面的运算符：

   Star & Star :: operator=(const char * ) { ... }
   

   另一种方法是使用转换函数将字符串转换成 Star 对象，然后使用将 Star 赋给 Star 的赋值函数。第一种方法的运行速度较快，但需要的代码较多，而使用转换函数可能导致编译器出现混乱。
   第18章将讨论 C++11新增的两个特殊方法：移动构造函数和移动赋值运算符。

其他的类方法

定义类时，还需要注意其他几点。下面的几小节将分别介绍。

1. 构造函数

   构造函数不同于其他类方法，因为它创建新的对象，而其他类方法只是被现有的对象调用。这是构造函数不被继承的原因之一。继承意味着派生类对象可以使用基类的方法，然而，构造函数在完成其工作之前，对象并不存在。

2. 析构函数
   一定要定义显式析构函数来释放类构造函数使用new分配的所有内存，并完成类对象所需的任何特殊清理工作。对于基类，即使它不需要析构函数，也应提供一个虚析构函数。

3. 转换
   使用一个参数就可以调用的构造函数定义了从参数类型到类类型的转换。例如，下述 Star 类的构造函数原型：

   Star (const char * );			// converts char * to Star
   Star (const Spectral &, int members = 1);		// converts Spectral to Star
   

   将可转换的类型传递给以类为参数的函数时，将调用转换构造函数。例如，在如下代码中：

   Star north;
   north = "poparis";
   

   第二条语句将调用 Star::operator=(const Star &) 函数，使用 Star::star(const char *)生成一个Star对象，该对象将被用作上述赋值运算符函数的参数。这里假设没有定义将 char * 赋给 Star 的赋值运算符。
   在带一个参数的构造函数原型中使用 explicit 将禁止进行隐式转换，但仍允许显式转换：

   class Star {
   ...
   public:
   	explicit Star (const char * );
   ...
   };
   ...
   Star north;
   north = "polaris";	// not allowed
   norht = Star("polaris")；	 // alowed
   

   要将类对象转换为其他类型，应定义转换函数。转换函数可以是没有参数的类成员函数，转换为double的转换函数定义如下：

   operator double() { ... }
   

   应理智地使用这样的函数，仅当它们有帮助时才使用。另外，对于某些类，包含转换函数将增加代码的二义性。例如，假设已经为第11章的 Vector 类型定义了 double 转换，并编写了下面的代码：

   Vector ius(6.0, 0.0);
   Vector lux = ius + 20.2;		// ambiguous
   

   编译器可以将 ius 转换成 double 并使用 double 加法，或将 20.2 转换成 vector（使用构造函数之一）并使用 vector 加法。但除了指出二义性外，它什么也不做。
   C++ 11 支持将关键字 explicit 用于转换函数。与构造函数一样，explicit 允许使用强制类型转换进行显式转换，但不允许隐式转换。

4. 按值传递对象与传递引用

   通常，编写使用对象作为参数的函数时，应按引用而不是按值来传递对象。这样做的原因之一是提高效率。按值传递对象涉及到生成临时拷贝，即调用复制构造函数，然后调用析构函数。调用这些函数需要时间，复制大型对象比传递引用花费的时间要多得多。如果函数不修改对象，应将参数声明为 const 引用。

   按引用传递对象的另外一个原因是，在继承使用虚函数时，被定义为接受基类引用参数的函数可以接受派生类。这在本章前面介绍过。

5. 返回对象和返回引用

   有些类方法返回对象。您可能注意到了，有些成员函数直接返回对象，而另一些则返回引用。有时方法必须返回对象，但如果可以不返回对象，则应返回引用。来具体看一下。
   首先，在编码方面，直接返回对象与返回引用之间唯一的区别在于函数原型和函数头：

   Star nova1(const Star &);		// returns a Star project
   Star & nova2(const Star &);	// returns a reference to a Star
   

   其次，应返回引用而不是返回对象的原因是，返回对象涉及生成返回对象的临时副本，这是调用函数的程序可以使用的副本。因此，返回对象的时间成本包括调用复制构造函数来生成副本所需的时间和调用析构函数删除副本所需的时间。返回引用可节省时间和内存。直接返回对象和按值传递对象相似：它们都生成临时副本。同样，返回引用和按引用传递对象相似：调用和被调用的函数对同一个对象进行操作。
   然而，并不总是可以返回引用。函数不能返回在函数中创建的临时对象的引用，因为当函数结束时，临时对象将消失，因此这种引用将是非法的。在这种情况下，应返回对象，以生成一个调用程序可以使用的副本。
   通用的规则是，如果函数返回在函数中创建的临时对象，则不要使用引用。例如，下面的方法使用构造函数来创建一个新对象，然后返回该对象的副本：

   Vector::Vector::operator+(const Vector & b) const {
   	return Vector(x+b.x, y+b.y);
   }
   

   如果函数返回的是通过引用或指针传递给它的对象，则应按引用返回对象。例如，下面的代码按引用返回调用函数的对象作为参数传递给函数的对象：

   const Stock & Stock::topval(const Stock & s) const{
   	if(s.total_val > total_val)
   		return s;		// argument abject
   	else
   		return *this;	// invoking object
   }
   

6. 使用 const
   使用 const 时应特别注意。可以用它来确保方法不修改参数：

   Star::Star(const char * s) { ... } // won't change the string to which s points
   

   可以使用 const 来确保方法不修改调用它的对象：

   void Star::show() const { ... } // won't change invoking object
   

   这里 const 表示 const Star * this，而 this 指向调用的对象。
   通常，可以将返回引用的函数放在赋值语句的左侧，这实际上意味着可以将值赋给引用的对象。但可以使用 const 来确保引用或指针返回的值不能用于修改对象中的数据：

   const Stock & Stock::topval(const Stock & s) const {
   	if (s.total_val > total_val)
   		return s;		// argument object
   	else
   		return *this;	// invoking object
   }
   

   该方法返回对 this 或 s 的引用。因为 this 和 s 都被声明为 const，所以函数不能对它们进行修改，这意味着返回的引用也必须被声明为 const。
   注意，如果函数将参数声明为指向 const 的引用或指针，则不能将该参数传递给另一个函数，除非后者也确保了参数不会被修改。