多态公有继承
同一个方法在派生类和基类中的行为是不同的。这种复杂的行为称为多态。有两种机制可以实现多态公有继承;
-
在派生类中重新定义基类的方法
-
使用虚方法
方法在基类被声明为虚的后,它在派生类中将自动成为虚方法。
//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);
double Balance() const;
virtual void Withdraw(double amt);
virtual void ViewAcct() const;
virtual ~Brass(){}
};
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 Withdraw(double amt);
virtual void ViewAcct() const;
void ResetMax(double m){
maxLoan = m;
}
void ResetRate(double r){
rate = r;
}
void ResetOwes(){
owesBank = 0;
}
};
#endif
#include <iostream>
#include "brass.h"
using std::cout;
using std::endl;
using std::string;
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 canceled.\n";
}
else{
balance += amt;
}
}
void Brass::Withdraw(double amt){
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 yours 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 << "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){
maxLoan = ml;
owesBank = 0.0;
rate = r;
}
//redefine how Withdraw() works
void BrassPlus::Withdraw(double amt) const{
//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(){
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);
}
为什么有两种类型的联编以及为什么默认为静态联编
动态联编能够重新定义类方法,而静态联编在这方面很差,为何不摒弃静态联编呢?原因有两个——效率和概念模型。
效率。为了能够在运行阶段进行决策,必须采取一些方法来跟踪基类指针或引用指向的对象类型,这增加了额外的处理开销。
概念模型。在设计类时,可能包含一些不在派生类重新定义的成员函数。不将该函数设置成虚函数,有两方面的好处:首先效率更高;其次,指出不要重新定义该函数。这表明,仅将那些预期被重新定义的方法声明为虚的。
虚函数的工作原理
每个类对象有一个隐藏成员,隐藏成员中保存了一个指向函数地址数组的指针。这种数组称为 虚函数表。虚函数表中存储了为类对象进行声明的虚函数的地址。
例如,基类对象包含一个指针,该指针指向基类中所有虚函数的地址表。派生类对象将包含一个指向独立地址表的指针。如果派生类提供了虚函数的新定义,该虚函数表将保存新函数的地址; 如果派生类没有重新定义虚函数,该虚函数表将保存函数原始版本的地址
调用虚函数时,程序将查看存储在对象中的虚函数表地址,然后转向相应的函数地址表。
使用虚函数时,在内存和执行速度上有一定的成本:
- 每个对象都将增大,增大量为存储地址的空间
- 对于每个类,编译器都创建一个虚函数地址表(数组);
- 对于每个函数调用,都需要到表中查找地址。
在一个虚函数的声明语句的分号前加上 =0;就可以将一个虚函数变成纯虚函数,其中,=0只能出现在类内部的虚函数声明语句处。纯虚函数只用声明,而不用定义,其存在就是为了提供接口,含有纯虚函数的类是抽象基类。我们不能直接创建一个抽象基类的对象,但可以创建其指针或者引用。值得注意的是,你也可以为纯虚函数提供定义,不过函数体必须定义在类的外部。但此时哪怕在外部定义了,也是纯虚函数,不能构建对象。
派生类构造函数只初始化它的直接基类。多继承的虚继承除外。
eg:
#include<iostream>
using namespace std;
//四边形
class Quadrilateral {
public:
virtual void print_area() = 0;
};
//正方形
class Square :public Quadrilateral
{
public:
Square(int c):a(c){}
void print_area()override
{
cout << "square " << a*a << endl;
}
private:
int a;
};
//矩形
class Rectangle: public Quadrilateral
{
public:
Rectangle(int a,int b) :R_long(a),R_width(b)
{
}
void print_area()override
{
cout << "rectangle " << R_long*R_width << endl;
}
private:
int R_long;
int R_width;
};
void paly(Quadrilateral &obj)
{
obj.print_area();
}
int main()
{
Square s1(10);
Rectangle r1(10, 20);
paly(s1);
paly(r1);
return 0;
}
这样用纯虚函数构建的抽象基类,能够为架构提供接口,如果现在要在前人代码的基础上增加一个平行四边形的面积打印,只用增加一个平行四边形的类,调用paly函数,不用再去更改原有的任何代码,而是在原有正确代码的基础上复用,这是构架的基础。纯虚函数应该在派生类中重写,否则派生类也是抽象类,不能实例化。
就像友元关系不能传递一样,友元关系同样不能继承,基类的友元在访问派生类成员时不具有特殊性,类似的,派生类的友元也不能随意访问基类的成员。