本文详细介绍了C++中的多态性，包括虚函数的概念、虚表与动态绑定的机制，以及如何通过虚函数实现运行时多态。同时，讨论了纯虚函数和抽象类的应用，以及`override`和`final`的关键字在派生和覆盖中的作用。此外，还阐述了运算符重载的重要性，展示了如何为自定义类重载加法、减法和前置/后置自增运算符。
第十八天: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
c1 = (5,4)
c2 = (2,10)
c3 = c1 - c2 =(3,0)
c3 = c1 + c2 =(7,14)
*/
- 表达式oprd B
#### 运算符重载为非成员函数的规则
* 函数的形参代表依自左至右次序排列的各操作数
* 重载为非成员函数时
* 参数个数 = 原操作数个数(后置++，--除外)
* 至少应该有一个自定义类型的参数
* 后置单目运算符 ++和--的重载函数，形参列表中要添加一个int，但不必写形参名
* 如果在运算符的重载函数中需要操作某类对象的私有成员，可以将此函数声明为该类的友元
#### 运算符重载为非成员函数的规则
* 双目运算符 B重载后
* 表达式oprd1 B oprd2
* 等同于operator B(oprd1,oprd2)
* 前置单目运算符 B重载后
* 表达式B oprd
* 等同于operator B(oprd)
* 后置单目运算符++和--重载后
* 表达式oprd B
* 等同于operator B(oprd,0)
扫一扫
2626
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
