首页计算机科学C++郑莉老师C++语言程序设计

# 第十八天：C++ 多态性

# 初始虚函数

  • 用 virtual 关键字说明的函数
  • 虚函数是实现运行时多态性的基础
  • C++ 中虚函数是动态绑定的函数
  • 虚函数必须是非静态的成员函数，虚函数经过派生之后，就可以实现 运行过程中 的多态

# 虚表与动态绑定

  • 虚表
    • 每个多态类有一个虚表 (virtual table)
    • 虚表中有当前类的各个虚函数的入口地址
    • 每个对象有一个指向当前类的虚表的指针 (虚指针 vptr)
  • 动态绑定的视线
    • 构造函数中为对象的虚指针赋值
    • 通过多态类型的指针或引用调用成员函数时，通过虚指针找到虚表，进而找到所调用的虚函数的入口地址
    • 通过该入口地址调用虚函数
      虚表示意图
#include <iostream>
using namespace std;
class Base1 // 基类 Base1 定义
{
public:
	// 虚函数
	virtual void display() const;
};
void Base1::display() const  //const 限制只读
{
	cout << "Base1::display" << endl; 
}
class Base2 : public Base1   // 公有派生类 Base2 继承
{
public:
	// 虚函数
	virtual void display() const; // 覆盖基类的虚函数
};
void Base2::display() const  //const 限制只读
{
	cout << "Base2::display" << endl;
}
class Derived : public Base2  // 公有派生类 Derived 定义
{
public:
	virtual void display() const; // 覆盖基类的虚函数
};
void Derived::display() const
{
	cout << "Derived::display" << endl;
}
void fun(Base1* ptr) // 参数为指向基类对象的指针
{
	ptr->display();// 对象指针 -> 成员名
}
int main(void)
{
	Base1 base1;  // 定义 Base1 类对象
	Base2 base2;  // 定义 Base2 类对象
	Derived derived; // 定义 Derived 类对象
	fun(&base1);  // 用 Base1 对象的指针调用 fun 函数
	fun(&base2);
	fun(&derived);
	return 0;
}
/* 
Base1::display
Base2::display
Derived::display
*/
# virtual 关键字
  • 派生类可以不显式地用 virtual 声明虚函数，这时系统就会用以下规则来判断派生类的一个函数是不是虚函数。
    • 该函数是否与基类的被覆盖的虚函数有相同的名称，参数个数及对应参数类型，cv 限定符 (是否 const)，引用限定符 (& 或 &&)
    • 该函数的返回值类型是否与基类被覆盖的虚函数返回值类型相同，或者可以隐含转换为基类被覆盖的虚函数的返回值类型
  • 如果派生类的函数满足上述条件，就会自动确定为虚函数，这时，派生类的虚函数便覆盖了基类的虚函数
  • 派生类中的虚函数还会隐藏基类中同名函数的所有其它重载类型
  • 一般习惯于在派生类的函数中也使用 virtual 关键字，以添加程序的可读性
# 哪些成员函数可以是虚函数
  • 一般非静态成员函数可以是虚函数
  • 构造函数不能是虚函数
  • 析构函数可以是虚函数
# 一般虚函数成员
  • 虚函数的声明
virtual 函数类型 函数名(形参表);
  • 虚函数声明只能出现在类定义中的函数原型声明中，而不能在成员函数实现的时候
  • 在派生类中可以对基类中的成员函数进行覆盖
  • 虚函数一般不声明为内联函数，因为对虚函数的调用需要动态绑定，而对内联函数的处理是静态的。
# 纯虚函数
  • 纯虚函数是一个在基类中声明的虚函数，它在该基类中没有定义具体的操作内容，要求各派生类根据实际需要定义自己的版本，纯虚函数的声明格式：
virtual 函数类型 函数名(参数表) = 0;
# 抽象类
  • 带有纯虚函数的类称为抽象类
class 类名
{
	virtual 类型 函数名(参数表) = 0;
	// 其他成员...
}
# 抽象类的作用:
  • 抽象类为抽象和设计的目的而声明
  • 将有关的数据和行为组织在一个继承层次结构中，保证派生类具有要求的行为；
  • 对于暂时无法实现的函数，可以声明为纯虚函数，留给派生类去实现
  • 注意:
    • 抽象类只能作为基类来使用
    • 不能定义抽象类的对象
/* 抽象类 
* 具有纯虚函数的类就叫做 “抽象类”
*/
#include <iostream>
using namespace std;
class Base1
{
public:
	virtual void display() const = 0; // 纯虚函数，函数没有结构体，等于 0
	// 抽象类是不能实例化的
};
class Base2 :public Base1
{
public:
	virtual void display() const;// 覆盖基类的虚函数
}; 
void Base2::display() const
{
	cout << "Base2::display()" << endl;
}
class Derived :public Base2
{
public:
	virtual void display() const; // 覆盖基类的虚函数
};
void Derived::display() const
{
	cout << "Derived::display()" << endl;
}
void fun(Base1* ptr)
{
	ptr->display();
}
int main(void)
{
	Base2 base2;
	Derived derived;
	fun(&base2);
	fun(&derived);
	return 0;
}
# 关键字 override 与 final
  • override 与 final 都不是语言关键字 (keyword)，只有在特定的位置才有特别含义，其他地方仍旧可以作为一般标识符 (identifier) 使用。
# override
  • 显式覆盖函数
  • 声明该函数必须覆盖基类的虚函数，编译器可发现 "未覆盖" 错误
  • 覆盖要求
    • 函数签名 (signature) 完全一致
    • 函数签名包括：函数名 参数列表 const
# 显式覆盖的作用
  • 声明显式函数覆盖，在编译期间发现未覆盖的错误
  • 运用显式覆盖，编译器会检查派生类中声明 ``overrid` 的函数，在基类中是否存在可被覆盖的虚函数，若不存在，则会报错
# final
  • 用来避免类被继承，或是基类的函数被覆盖
struct Base final
{
};
struct Derived:Base1 // 编译错误，Base1 为 final 不允许被继承
{
}
// 或
struct Base2
{
	virtual void f() final; // 此函数不能被派生类修改或覆盖
}; 
struct Derived2:Base2
{
	void f(); // 编译错误，不允许被覆盖
}
# 运算符重载的意义
  • 运算符重载是对已有的运算符赋予多重含义，使同一个运算的数据时导致不同的行为
  • 针对自定义的类，可以对原有运算符进行重载
# 例如
  • 使复数类的对象可以用 "+" 运算符实现算法
  • 是时钟类可以用 "++" 运算符实现时间增加 1 秒
# 运算符重载的规定
  • C 几乎可以重载全部的运算符，而且只能重载 C 中已经有的
    • 不能重载:".",".*","::","?:"
  • 重载之后运算符的优先级和结合性都不会改变
  • 可以重载为类的非静态成员函数
  • 可以重载为非成员函数 (必要时可以声明为友元)
# 运算符重载为成员函数
  • 复数类加减法运算重载为成员函数
#include <iostream>
using namespace std;
class Complex
{
public:
	Complex(double r = 0.0, double i = 0.0) :real(r), imag(i)
	{
	}
	// 运算符 + 重载成员函数
	Complex operator + (const Complex& c2) const;
	// 运算符 - 重载函数成员
	Complex operator - (const Complex& c2) const;
	void display() const; // 输出复数
private:
	double real; // 复数实部
	double imag; // 复数虚部
};
Complex Complex::operator+(const Complex& c2) const
{
	// 创建一个临时无名对象作为返回值
	return Complex(real + c2.real, imag + c2.imag);
}
Complex Complex::operator- (const Complex & c2) const // 左操作数，右操作数
{
	return Complex(real - c2.real, imag - c2.imag);
}
void Complex::display() const
{
	cout << "(" << real << "," << imag << ")" << endl;
}
int main(void)
{
	Complex c1(5, 4), c2(2, 10), c3;
	cout << "c1 = ";
	c1.display();
	cout << "c2 = ";
	c2.display();
	c3 = c1 - c2;  // 使用重载运算符完成复数减法
	cout << "c3 = c1 - c2 =";
	c3.display();
	c3 = c1 + c2; // 使用重载运算符完成复数加法
	cout << "c3 = c1 + c2 =";
	c3.display();
	return 0;
}
/*
c1 = (5,4)
c2 = (2,10)
c3 = c1 - c2 =(3,-6)
c3 = c1 + c2 =(7,14)
*/
# 重载为类成员的运算符函数定义形式
函数类型 operator 运算符(形参)
{
	....
}
// 参数个数 = 原操作数个数 - 1 (后置 ++，-- 除外)
# 双目运算符重载规则
  • 如果要重载 B 为类成员函数，使之能够实现表达式 oped1 B oped2, 其中 oprd1 为类对象，则 B 应被重载为 A 类的成员函数，形参类型应该是 oprd2 所属的类型
  • 经重载后，表达式 oprd B oprd2 相当于 oprd1.operator B (oprd2)
# 重载前置和后置为时钟类成员函数
  • 前置单目运算符，重载函数没有形参
  • 后置 ++ 运算符，重载函数需要有一个 int 形参
  • 操作数是时钟类的对象
  • 实现时间增加 1 秒钟
#include <iostream>
using namespace std;
class Clock
{
public:
	Clock(int hour = 0, int minute = 0, int second = 0);
	void showTime() const;
	// 前置单目运算符重载
	Clock& operator ++ ();
	// 后置单目运算符重载
	Clock operator ++ (int);  //int 区分前置后置
private:
	int hour, minute, second;
};
Clock::Clock(int hour, int minute, int second)
{
	if (0 <= hour && hour < 24 && 0 <= minute && minute < 60 && 0 <=second &&second <60)
	{
		this->hour = hour;
		this->minute = minute;
		this->second = second;
	}
	else
	{
		cout << "Time error!" << endl;
	}
}
void Clock::showTime() const // 显示时间
{
	cout << hour << ":" << minute << ":" << second << endl;
}
Clock& Clock::operator++() // 前置 ++
{ 
	second++;
	if (second >= 60)
	{
		second -= 60;
		minute++;
		if (minute >= 60)
		{
			minute -= 60;
			hour = (hour + 1) % 24;
		}
	}
	return *this;
}
Clock Clock::operator++(int)  // 后置 ++
{
	// 注意形参表中额整型参数
	Clock old = *this;
	++(*this);  // 调用前置 “++” 运算符
	return old;  // 返回当前值之后才加加
}
int main(void)
{
	Clock myclock(23, 59, 59);
	cout << "First time output:";
	myclock.showTime();
	cout << "Show myclock++";
	(myclock++).showTime();
	cout << "Show ++myclock:";
	(++myclock).showTime();
	return 0;
}
/*
First time output:23:59:59
Show myclock++23:59:59
Show ++myclock:0:0:1
*/
# 前置单目运算符
  • 如果要重载 U 为类成员函数，使之能够实现表达式 U oprd ，其中 oprd 为 A 类兑现，则 U 应被重载为 A 类的成员函数，无形参
  • 经重载后，表达式 U oprd 相当于 oprd.operator U()
# 后置单目运算符 ++ 和 -- 重载规则
  • 如果要重载或 -- 为类成员函数，使之能够实现表达式 oprd++ 或 oprd-- ，其中 oprd 为 A 类对象，则或 -- 应被重载为 A 类的成员函数，且具有一个 int 类型形参
  • 经重载后，表达式 oprd++ 相当于 oprd.operator++(0)
# 运算符重载为非成员函数
有些运算符不能重载为成员函数，例如：二元运算符的左操作数不是对象，或者是不能由我们重载运算符的对象
# 例题：重载 Complex 的加减法和 "<<" 运算符为非成员函数
  • 将 +，-(双目) 重载为非成员函数，并将其声明为复数类的友元，两个操作数都是复数类的常引用
  • 将 <<(双目) 重载为非成员函数，并将其声明为复数类的友元，它的左操作数是 std::ostream 引用，右操作符为复数类的常引用，返回 std::ostream 引用，用以支持下面形式的输出:
    输出流
cout<<a<<b;
// 该输出调用的是
operator<<(operator<<(cout,a),b);
# 实现
#include <iostream>
using namespace std;
class Complex
{
public:
	Complex(double r = 0.0, double i = 0.0) :real(r), imag(i)
	{
	}
	// 运算符 + 重载成员函数
	friend Complex operator + (const Complex& c1,const Complex& c2); // 友元函数
	// 运算符 - 重载函数成员
	friend Complex operator - (const Complex& c1,const Complex& c2);
	friend ostream& operator<<(ostream& out, const Complex& c);
private:
	double real; // 复数实部
	double imag; // 复数虚部
};
Complex operator+(const Complex& c1, const Complex& c2) // 传引用效率更高，常引用，只能取数 ，不能修改
{
	return Complex(c1.real + c2.real, c1.imag + c2.imag);
}
Complex operator- (const Complex& c1, const Complex& c2) // 左操作数，右操作数
{
	return Complex(c1.real - c2.real, c2.imag - c2.imag);
}
ostream& operator<<(ostream& out, const Complex& c) // 流对象
{
	out << "(" << c.real << "," << c.imag << ")";
	return out;
}
int main(void)
{
	Complex c1(5, 4), c2(2, 10), c3;
	cout << "c1 = " << c1 << endl;
	cout << "c2 = " << c2 << endl;
	c3 = c1 - c2;  // 使用重载运算符完成复数减法
	cout << "c3 = c1 - c2 =" << c3 << endl;
	c3 = c1 + c2; // 使用重载运算符完成复数加法
	cout << "c3 = c1 + c2 =" << c3 << endl;
	return 0;
}
/*
c1 = (5,4)
c2 = (2,10)
c3 = c1 - c2 =(3,0)
c3 = c1 + c2 =(7,14)
*/
# 运算符重载为非成员函数的规则
  • 函数的形参代表依自左至右次序排列的各操作数
  • 重载为非成员函数时
    • 参数个数 = 原操作数个数 (后置 ++，-- 除外)
    • 至少应该有一个自定义类型的参数
  • 后置单目运算符 ++ 和 -- 的重载函数，形参列表中要添加一个 int，但不必写形参名
  • 如果在运算符的重载函数中需要操作某类对象的私有成员，可以将此函数声明为该类的友元
# 运算符重载为非成员函数的规则
  • 双目运算符 B 重载后
    • 表达式 oprd1 B oprd2
    • 等同于 operator B (oprd1,oprd2)
  • 前置单目运算符 B 重载后
    • 表达式 B oprd
    • 等同于 operator B (oprd)
  • 后置单目运算符 ++ 和 -- 重载后
    • 表达式 oprd B
    • 等同于 operator B (oprd,0)