【捡起C++】类继承

多态公有继承

​ 同一个方法在派生类和基类中的行为是不同的。这种复杂的行为称为多态。有两种机制可以实现多态公有继承；

• 在派生类中重新定义基类的方法

• 使用虚方法

  方法在基类被声明为虚的后，它在派生类中将自动成为虚方法。

//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函数，不用再去更改原有的任何代码，而是在原有正确代码的基础上复用，这是构架的基础。纯虚函数应该在派生类中重写，否则派生类也是抽象类，不能实例化。

​ 就像友元关系不能传递一样，友元关系同样不能继承，基类的友元在访问派生类成员时不具有特殊性，类似的，派生类的友元也不能随意访问基类的成员。