第13章 类继承
类库由类声明和实现构成的。通常，类库是以源代码的方式提供的。
C++提供了比修改代码更好的方法来扩展和修改类。这种方法叫做类继承，它能够从已有的类派生出新的类，而派生类继承了原有类（称为基类）的特征，包括方法。通过继承派生出的类通常比设计新类要容易。下面是可以通过继承完成的一些工作：
可以在已有类的基础上添加功能；
可以给类添加数据；
可以修改类方法的行为；
13.1 一个简单的基类
从一个类派生出另一个类时，原始类称为基类，继承类称为派生类。下面首先建立一个基类：
// tabtenn0.h -- a table-tennis base class
#ifndef TABTENN0_H_
#define TABTENN0_H_
#include <string>
using std::string;
// simple base class
class TableTennisPlayer
{
private:
string firstname;
string lastname;
bool hasTable;
public:
TableTennisPlayer (const string & fn = "none",
const string & ln = "none", bool ht = false);
void Name() const;
bool HasTable() const { return hasTable; };
void ResetTable(bool v) { hasTable = v; };
};
#endif
cpp文件为：
//tabtenn0.cpp -- simple base-class methods
#include "tabtenn0.h"
#include <iostream>
TableTennisPlayer::TableTennisPlayer (const string & fn,
const string & ln, bool ht) : firstname(fn),
lastname(ln), hasTable(ht) {}
void TableTennisPlayer::Name() const
{
std::cout << lastname << ", " << firstname;
}
13.1.1 派生一个类
首先将RatedPlayer类声明为从TablesTennisClass类派生而来：
// RatedPlayer derives from the TableTennisPlayer base class
class RatedPlayer:public TableTennisPlayer
{
...
}
冒号指出RatedPlayer类的基类是TableTennisplayer类。上述特殊的声明头声明TableTennisplayer是一个公有基类，这被称为公有派生。使用公有派生，基类的公有成员将称为派生类的公有成员；基类的私有部分也将成为派生类的一部分，但只能通过基类的公有和保护方法访问。
RatedPlayer对象将具有以下特征：
派生类对象存储了基类的数据成员（派生类继承了基类的实现）；
派生类对象可以使用基类的方法（派生类继承了基类的接口）；
继承特性中需要添加：
派生类需要自己的构造函数
派生类可以根据需要添加额外的数据成员和成员函数
派生类的类声明可以如下：
//simple derived class
class RatedPlayer:public TableTennisPlayer
{
private:
unsigned int rating; //add a data member
pubilc:
RatedPlayer(unsigned int r=0,const string & fn="none",const string & ln="none",bool ht=false);
RatedPlayer(usigned int r,const TableTennisPlayer & tp);
unsigned int Rating()const{return rating;}
void ResetRating(unsigned int r){rating = r;}
}
在第一个RatedPlayer构造函数中，每个成员对应一个形参；而第二个RatedPlayer构造函数使用一个TableTennisPlayer参数。
13.1.2 构造函数：访问权限的考虑
派生类不能直接访问基类的私有成员，而必须通过基类方法进行访问。
第一个RatedPlayer构造函数的代码：
RatedPlayer：：RatedPlayer（unsigned int r,const string &fn,const
string &ln,bool ht）:TableTennisPlayer(fn,ln,ht)
{
rating=r;
}
第二个构造函数的代码：
RatedPlayer：：RatedPlayer（unsigned int r,const TableTennisPlayer & tp）:TableTennis Player(tp)
{
rating=r;
}
上述代码也可以写为：
RatedPlayer：：RatedPlayer（unsigned int r,const TableTennisPlayer & tp）:TableTennis Player(tp),rating(r)
{
}
有关派生类构造函数的要点如下：
首先创建基类对象；
派生类构造函数应通过成员初始化列表将基类信息传递给基类构造函数；
派生类构造函数应初始化派生类新增的数据成员；
创建派生类对象时，程序首先调用基类构造函数，然后再调用派生类构造函数。当派生类对象过期时，程序将首先调用派生类析构函数，然后再调用基类析构函数。
13.1.3 使用派生类
要使用派生类，程序必须能够访问基类声明。可以将两种类的声明置于同一个头文件中，也可以将每个类放在独立的头文件中。
13.1.4 派生类和基类之间的特殊关系
派生类对象可以使用基类的方法，前提条件是方法不是私有的：
RatedPlayer rplayer1(1140,"Mallory","Duck",true);
rplayer1.Name(); //derived object uses base method
基类指针可以在不进行显式类型转换的情况下指向派生类对象；
基类引用可以在不进行显式类型转换的情况下引用派生类对象：
RatedPlayer rplayer1(1140,"Mallory","Duck",true);
TableTennisPlayer & rt=rplayer;
TableTennisPlayer * pt= &rplayer;
rt.Name(); //invoke Name() with reference
pt->Name(); //invoke Name() with pointer
基类指针或引用智能用于调用基类方法，因此，不能使用rt或Pt来调用派生类的方法。
13.2 继承：is-a关系
is-a关系，即派生类对象也是一个基类对象，可以对基类对象执行的任何操作，也可以对派生类对象执行。
13.3 多态公有继承
有时在程序中希望方法的行为应取决于调用该方法的对象。这种较复杂的行为称为多态—具有多种形态，即同一个方法的行为随上下文而异。有两种重要的机制可用于实现多态公有继承：
在派生类重新定义基类的方法
使用虚方法
范例类声明：
// brass.h -- bank account classes
#ifndef BRASS_H_
#define BRASS_H_
#include <string>
// Brass Account Class
class Brass
{
private:
std::string fullName;
long acctNum;
double balance;
public:
Brass(const std::string & s = "Nullbody", long an = -1,
double bal = 0.0);
void Deposit(double amt);
virtual void Withdraw(double amt);
double Balance() const;
virtual void ViewAcct() const;
virtual ~Brass() {}
};
//Brass Plus Account Class
class BrassPlus : public Brass
{
private:
double maxLoan;
double rate;
double owesBank;
public:
BrassPlus(const std::string & s = "Nullbody", long an = -1,
double bal = 0.0, double ml = 500,
double r = 0.11125);
BrassPlus(const Brass & ba, double ml = 500,
double r = 0.11125);
virtual void ViewAcct()const;
virtual void Withdraw(double amt);
void ResetMax(double m) { maxLoan = m; }
void ResetRate(double r) { rate = r; };
void ResetOwes() { owesBank = 0; }
};
#endif
对于上述的类声明有以下几点需要说明：
Brass类在声明ViewAcct( )和Withdraw( )时使用了新关键字virtual。这些方法被称为虚方法。
Brass类声明了一个虚析构函数，虽然该析构函数不执行任何操作
两个ViewAcct( )原型表明将有2个独立的方法定义。基类版本的限定名为Brass::ViewAcct()，派生类版本的限定名为BrassPlus::ViewAcct( )。
如果要在派生类中重新定义基类的方法，通常应将基类方法声明为虚的。
1）类实现
关键字virtual只用于类声明的方法原型中，而没有用在类方法实现中
// brass.cpp -- bank account class methods
#include <iostream>
#include "brass.h"
using std::cout;
using std::endl;
using std::string;
// formatting stuff
typedef std::ios_base::fmtflags format;
typedef std::streamsize precis;
format setFormat();
void restore(format f, precis p);
// Brass methods
Brass::Brass(const string & s, long an, double bal)
{
fullName = s;
acctNum = an;
balance = bal;
}
void Brass::Deposit(double amt)
{
if (amt < 0)
cout << "Negative deposit not allowed; "
<< "deposit is cancelled.\n";
else
balance += amt;
}
void Brass::Withdraw(double amt)
{
// set up ###.## format
format initialState = setFormat();
precis prec = cout.precision(2);
if (amt < 0)
cout << "Withdrawal amount must be positive; "
<< "withdrawal canceled.\n";
else if (amt <= balance)
balance -= amt;
else
cout << "Withdrawal amount of $" << amt
<< " exceeds your balance.\n"
<< "Withdrawal canceled.\n";
restore(initialState, prec);
}
double Brass::Balance() const
{
return balance;
}
void Brass::ViewAcct() const
{
// set up ###.## format
format initialState = setFormat();
precis prec = cout.precision(2);
cout << "Client: " << fullName << endl;
cout << "Account Number: " << acctNum << endl;
cout << "Balance: $" << balance << endl;
restore(initialState, prec); // Restore original format
}
// BrassPlus Methods
BrassPlus::BrassPlus(const string & s, long an, double bal,
double ml, double r) : Brass(s, an, bal)
{
maxLoan = ml;
owesBank = 0.0;
rate = r;
}
BrassPlus::BrassPlus(const Brass & ba, double ml, double r)
: Brass(ba) // uses implicit copy constructor
{
maxLoan = ml;
owesBank = 0.0;
rate = r;
}
// redefine how ViewAcct() works
void BrassPlus::ViewAcct() const
{
// set up ###.## format
format initialState = setFormat();
precis prec = cout.precision(2);
Brass::ViewAcct(); // display base portion
cout << "Maximum loan: $" << maxLoan << endl;
cout << "Owed to bank: $" << owesBank << endl;
cout.precision(3); // ###.### format
cout << "Loan Rate: " << 100 * rate << "%\n";
restore(initialState, prec);
}
// redefine how Withdraw() works
void BrassPlus::Withdraw(double amt)
{
// set up ###.## format
format initialState = setFormat();
precis prec = cout.precision(2);
double bal = Balance();
if (amt <= bal)
Brass::Withdraw(amt);
else if ( amt <= bal + maxLoan - owesBank)
{
double advance = amt - bal;
owesBank += advance * (1.0 + rate);
cout << "Bank advance: $" << advance << endl;
cout << "Finance charge: $" << advance * rate << endl;
Deposit(advance);
Brass::Withdraw(amt);
}
else
cout << "Credit limit exceeded. Transaction cancelled.\n";
restore(initialState, prec);
}
format setFormat()
{
// set up ###.## format
return cout.setf(std::ios_base::fixed,
std::ios_base::floatfield);
}
void restore(format f, precis p)
{
cout.setf(f, std::ios_base::floatfield);
cout.precision(p);
}
13.4.3 有关虚函数注意事项
虚函数的一些要点：
在基类方法的声明中使用关键字virtual 可使该方法在基类及所有的派生类中是虚的
如果使用指向对象的引用或指针来调用虚方法，程序将使用对象类型定义的方法，而不使用为引用或指针类型定义的方法。这称为动态联编或晚期联编。
如果定义的类将被用作基类，则应将那些要在派生类中重新定义的类方法声明为虚的
1）构造函数
构造函数不能是虚函数
2）析构函数
析构函数应当是虚函数，除非类不作为基类
3）友元
友元不能是虚函数，因为友元不是类成员，而只有成员才能是虚函数。
5）重新定义将隐藏方法
有两台经验规则：
如果重新定义继承的方法，应确保与原来的原型完全相同。
如果基类声明被重载了，则应在派生类中重新定义所有的基类版本。
13,.5 访问控制：protected
保护类别用关键字protected表示。
派生类的成员可以直接访问基类的保护成员，但不能直接访问基类的私有成员。所以，对于外部世界来说，保护成员的行为与私有成员相似；但对于派生类来说，保护成员的行为与公有成员相似。
13.6 抽象基类（ABC）
要成为真正的ABC，必须至少包含一个纯虚函数。则此时函数原型声明为：
void Move(int nx,ny)=0;
类方法则为：
void BaseEllipse::Move(int nx,ny) {x=ny;y=ny;}
13.7 继承和动态内存分配
如果派生类使用动态内存分配，有以下几个小技巧：
13.7.1 第一种：派生类不使用new
此时不需要为派生类定义显式析构函数、复制构造函数和赋值运算符。
13.7.2 第二种情况：派生类使用new
'假设派生类使用了new:
// derived class with DMA
class hasDMA:public baseDMA
{
private:
char * style; //use new in constructors
public:
...
};
在这种情况下，必须为派生类定义显式析构函数、复制构造函数和赋值运算符。
显式定义析构函数：
hasDMA::~hasDMA()
{
delete [] style;
}
显式复制构造函数：
hasDMA::hasDMA(const hasDMA & hs):baseDMA(hs)
{
style = new char[std::strlen(hs.style)+1];
std::strcpy(style,hs.style);
}
显式赋值运算符：
hasDMA & hasDMA::operator=(const hasDMA &hs)
{
if(this==&hs)
return *this;
baseDMA::operator=(hs);
delete [] style;
style = new char[std::strlen(hs.style)+1];
std::strcpy(style.hs.style);
return *this;
}