1
第八章 多态性湖南科技大学 莫尚丰
C++语言程序设计
C++语言程序设计 湖南科技大学
2
本章主要内容
多态性
运算符重载
虚函数
纯虚函数
抽象类
C++语言程序设计 湖南科技大学
3
多态性的概念
多态性是面向对象程序设计的重要特征之一。
多态性是指发出同样的消息被不同类型的对象接收时有可能导致完全不同的行为。
多态的实现：
– 函数重载
– 运算符重载
– 虚函数
C++语言程序设计 湖南科技大学
4
问题举例 —— 复数的运算
class complex //复数类声明
{
public:
complex(double r=0.0,double i=0.0) //构造函数
{ real=r; imag=i; }
void display(); //显示复数的值
private:
double real;
double imag;
};
运算符重载
C++语言程序设计 湖南科技大学
5
问题举例 —— 复数的运算
用,+”、,-”能够实现复数的加减运算吗？
实现复数加减运算的方法
—— 重载,+”、,-”运算符运算符重载
C++语言程序设计 湖南科技大学
6
运算符重载的实质
运算符重载是对已有的运算符赋予多重含义
必要性
– C++中预定义的运算符其运算对象只能是基本数据类型，而不适用于用户自定义类型（如类）
实现机制
– 将指定的运算表达式转化为对运算符函数的调用，运算对象转化为运算符函数的实参。
– 编译系统对重载运算符的选择，遵循函数重载的选择原则。
运算符重载
C++语言程序设计 湖南科技大学
7
运算符重载规则和限制
可以重载 C++中除下列运算符外的所有运算符：
.,*,,?,sizeof
只能重载 C++语言中已有的运算符，
不可臆造新的。
不改变原运算符的优先级和结合性。
不能改变操作数个数。
经重载的运算符，其操作数中至少应该有一个是自定义类型。
C++语言程序设计 湖南科技大学
8
两种形式
重载为类成员函数。
重载为友元函数。
运算符重载
C++语言程序设计 湖南科技大学
9
运算符函数
声明形式函数类型 operator 运算符（形参）
{
......
}
重载为类成员函数时参数个数 =原操作数个数 -1（后置 ++,--除外）
重载为友元函数时 参数个数 =原操作数个数,
且至少应该有一个自定义类型的形参。
运算符重载
C++语言程序设计 湖南科技大学
10
运算符成员函数的设计
双目运算符 B
– 如果要重载 B 为类成员函数，使之能够实现表达式 oprd1 B oprd2，其中 oprd1 为 A
类对象，则 B 应被重载为 A 类的成员函数，
形参类型应该是 oprd2 所属的类型。
– 经重载后，表达式 oprd1 B oprd2 相当于
oprd1.operator B(oprd2)
运算符重载
C++语言程序设计 湖南科技大学
11
运算符重载例 8-1
将,+”,,-” 运算重载为复数类的成员函数。
规则,
– 实部和虚部分别相加减。
操作数,
– 两个操作数都是复数类的对象。
#include<iostream>
using namespace std;
class complex //复数类声明
{
public,//外部接口
complex(double r=0.0,double i=0.0){real=r;imag=i;}
//构造函数
complex operator + (complex c2); //+重载为成员函数
complex operator - (complex c2); //-重载为成员函数
void display(); //输出复数
private,//私有数据成员
double real; //复数实部
double imag; //复数虚部
};
12
complex complex::
operator +(complex c2) //重载函数实现
{
complex c;
c.real=c2.real+real;
c.imag=c2.imag+imag;
return complex(c.real,c.imag);
}
13
complex complex::
operator -(complex c2) //重载函数实现
{
complex c;
c.real=real-c2.real;
c.imag=imag-c2.imag;
return complex(c.real,c.imag);
}
14
void complex::display()
{ cout<<"("<<real<<","<<imag<<")"<<endl; }
int main() //主函数
{ 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();
}
15
程序输出的结果为：
c1=(5,4)
c2=(2,10)
c3=c1-c2=(3,-6)
c3=c1+c2=(7,14)
16
C++语言程序设计 湖南科技大学
17
运算符成员函数的设计
前置单目运算符 U
– 如果要重载 U 为类成员函数，使之能够实现表达式 U oprd，其中 oprd 为 A类对象，则 U 应被重载为 A 类的成员函数，
无形参。
– 经重载后，
表达式 U oprd 相当于 oprd.operator U()
运算符重载
C++语言程序设计 湖南科技大学
18
运算符成员函数的设计
后置单目运算符 ++和 --
– 如果要重载 ++或 --为类成员函数，使之能够实现表达式 oprd++ 或 oprd--,其中 oprd 为 A类对象，则 ++或 -- 应被重载为 A 类的成员函数，且具有一个 int
类型 形参 。
– 经重载后，表达式 oprd++ 相当于
oprd.operator ++(0)
运算符重载
C++语言程序设计 湖南科技大学
19
例 8-2
运算符前置 ++和后置 ++重载为时钟类的成员函数。
前置单目运算符，重载函数没有形参，
对于后置单目运算符，重载函数需要有一个整型形参。
操作数是时钟类的对象。
实现时间增加 1秒钟。
运算符重载
//8_2.cpp
#include<iostream>
using namespace std;
class Clock //时钟类声明
{
public,//外部接口
Clock(int NewH=0,int NewM=0,int NewS=0);
void ShowTime();
Clock& operator ++(); //前置单目运算符重载
Clock operator ++(int); //后置单目运算符重载
private,//私有数据成员
int Hour,Minute,Second;
};
20
Clock& Clock::operator ++() //前置单目运算符重载函数
{ Second++;
if(Second>=60)
{ Second=Second-60;
Minute++;
if(Minute>=60)
{
Minute=Minute-60;
Hour++;
Hour=Hour%24;
}
}
return *this;
}
21
//后置单目运算符重载
Clock Clock::operator ++(int)
{ //注意形参表中的整型参数
Clock old=*this;
++(*this);
return old;
}
22
//其它成员函数的实现略
int main()
{
Clock myClock(23,59,59);
cout<<"First time output:";
myClock.ShowTime();
cout<<"Show myClock++:";
(myClock++).ShowTime();//后置单目运算
cout<<"Show ++myClock:";
(++myClock).ShowTime();//前置单目运算符
}
23
程序运行结果为：
First time output,23:59:59
Show myClock++,23:59:59
Show ++myClock,0:0:1
24
C++语言程序设计 湖南科技大学
25
运算符友元函数的设计
如果需要重载一个运算符，使之能够用于操作某类对象的私有成员，可以将此运算符重载为该类的友元函数。
函数的形参代表依次左至右次序排列的各操作数。
后置单目运算符 ++和 --的重载函数，
形参列表中要增加一个 int，但不必写形参名。
运算符重载
C++语言程序设计 湖南科技大学
26
运算符友元函数的设计
双目运算符 B重载后，
表达式 oprd1 B oprd2
等同于 operator B(oprd1,oprd2 )
前置单目运算符 B重载后，
表达式 B oprd
等同于 operator B(oprd )
后置单目运算符 ++和 --重载后，
表达式 oprd B
等同于 operator B(oprd,0 )
运算符重载
C++语言程序设计 湖南科技大学
27
例 8-3
将 +,-（双目）重载为复数类的友元函数。
两个操作数都是复数类的对象。
运算符重载
#include<iostream>
using namespace std;
class complex //复数类声明
{
public,//外部接口
complex(double r=0.0,double i=0.0)
{ real=r; imag=i; } //构造函数
friend complex operator + (complex c1,complex c2);
//运算符 +重载为友元函数
friend complex operator - (complex c1,complex c2);
//运算符 -重载为友元函数
void display(); //显示复数的值
private,//私有数据成员
double real;
double imag;
};
28
complex operator +(complex c1,complex c2)
//运算符重载友元函数实现
{ return
complex(c2.real+c1.real,c2.imag+c1.imag);
}
complex operator -(complex c1,complex c2)
//运算符重载友元函数实现
{ return
complex(c1.real-c2.real,c1.imag-c2.imag);
}
// 其他函数和主函数同例 8-1
29
C++语言程序设计 湖南科技大学
30
静态绑定与动态绑定
绑定
– 程序自身彼此关联的过程，确定程序中的操作调用与执行该操作的代码间的关系。
静态绑定
– 绑定过程出现在编译阶段，用对象名或者类名来限定要调用的函数。
动态绑定
– 绑定过程工作在程序运行时执行，在程序运行时才确定将要调用的函数。
C++语言程序设计 湖南科技大学
35
虚函数
虚函数是动态绑定的基础。
是非静态的成员函数。
在类的声明中，在函数原型之前写 virtual。
virtual 只用来说明类声明中的原型，不能用在函数实现时 (即,函数实现前面不能有 virtual )。
具有继承性，基类中声明了虚函数，派生类中无论是否说明，同原型函数都自动为虚函数。
本质：不是重载声明而是覆盖。
调用方式：通过基类指针或引用，执行时会根据 指针指向的对象的类,决定调用哪个函数。
虚函数
C++语言程序设计 湖南科技大学
36
例 8-4
#include <iostream>
using namespace std;
class B0 //基类 B0声明
{public,//外部接口
virtual void display() //虚成员函数
{cout<<"B0::display()"<<endl;}
};
class B1,public B0 //公有派生
{ public:
void display() { cout<<"B1::display()"<<endl; }
};
class D1,public B1 //公有派生
{ public:
void display() { cout<<"D1::display()"<<endl; }
};
虚函数
void fun(B0 *ptr) //普通函数
{ ptr->display(); }
int main() //主函数
{ B0 b0,*p; //声明基类对象和指针
B1 b1; //声明派生类对象
D1 d1; //声明派生类对象
p=&b0;
fun(p); //调用基类 B0函数成员
p=&b1;
fun(p); //调用派生类 B1函数成员
p=&d1;
fun(p); //调用派生类 D1函数成员
}
运行结果：
B0::display()
B1::display()
D1::display()
37
C++语言程序设计 湖南科技大学
38
虚析构函数何时需要虚析构函数？
当你可能通过基类指针删除派生类对象时
如果你打算允许其他人通过基类指针调用对象的析构函数（通过 delete这样做是正常的），并且被析构的对象是有重要的析构函数的派生类的对象，
就需要让基类的析构函数成为虚拟的。
虚函数
C++语言程序设计 湖南科技大学
39
例 8-5
#include <iostream>
using namespace std;
class Base
{ public,//外部接口
~Base(){ cout<< "Base destructor\n";}
};
class Derived,public Base //公有派生
{ public:
Derived();
~Derived();
private:
int *i_pointer;
};
C++语言程序设计 湖南科技大学
40
Derived::Derived()
{ i_pointer=new int(0); }
Derived::~Derived()
{
cout<< "Derived destructor\n";
delete i_pointer;
}
void fun(Base* b)
{ delete b; }
int main()
{
Base *b=new Derived();
fun(b);
}
运行结果：
Base destructor
C++语言程序设计 湖南科技大学
41
避免上述错误的有效方法是声明析构函数为虚函数：
class Base
{ public,//外部接口
virtual ~Base(){ cout<< "Base destructor\n";}
};
运行结果：
Derived destructor
Base destructor
C++语言程序设计 湖南科技大学
42
抽象类带有纯虚函数的类称为抽象类,
class 类名
{
virtual 类型 函数名 (参数表 )=0;
//纯虚函数
...
}
纯虚函数与抽象类
C++语言程序设计 湖南科技大学
43
抽象类纯虚函数与抽象类
作用
– 抽象类为抽象和设计的目的而声明，将有关的数据和行为组织在一个继承层次结构中，保证派生类具有要求的行为。
– 对于暂时无法实现的函数，可以声明为纯虚函数，
留给派生类去实现。
注意
– 抽象类只能作为基类来使用。
– 不能声明抽象类的对象。
– 构造函数不能是虚函数，析构函数可以是虚函数。
C++语言程序设计 湖南科技大学
44
例 8-6
纯虚函数与抽象类
#include <iostream>
using namespace std;
class B0 //抽象基类 B0声明
{ public,//外部接口
virtual void display( )=0; //纯虚函数成员
};
class B1,public B0 //公有派生
{ public:
void display(){cout<<"B1::display()"<<endl;} //虚成员函数
};
class D1,public B1 //公有派生
{ public:
void display(){cout<<"D1::display()"<<endl;} //虚成员函数
};
void fun(B0 *ptr) //普通函数
{ ptr->display(); }
int main() //主函数
{ B0 *p; //声明抽象基类指针
B1 b1; //声明派生类对象
D1 d1; //声明派生类对象
p=&b1;
fun(p); //调用派生类 B1函数成员
p=&d1;
fun(p); //调用派生类 D1函数成员
}
运行结果：
B1::display()
D1::display()
45
C++语言程序设计 湖南科技大学
46
小结与复习建议
主要内容
– 多态性的概念、运算符重载、虚函数、
纯虚函数、抽象类
达到的目标
– 理解多态的概念，学会运用多态机制。
实验任务
– 实验八
第八章 多态性湖南科技大学 莫尚丰
C++语言程序设计
C++语言程序设计 湖南科技大学
2
本章主要内容
多态性
运算符重载
虚函数
纯虚函数
抽象类
C++语言程序设计 湖南科技大学
3
多态性的概念
多态性是面向对象程序设计的重要特征之一。
多态性是指发出同样的消息被不同类型的对象接收时有可能导致完全不同的行为。
多态的实现：
– 函数重载
– 运算符重载
– 虚函数
C++语言程序设计 湖南科技大学
4
问题举例 —— 复数的运算
class complex //复数类声明
{
public:
complex(double r=0.0,double i=0.0) //构造函数
{ real=r; imag=i; }
void display(); //显示复数的值
private:
double real;
double imag;
};
运算符重载
C++语言程序设计 湖南科技大学
5
问题举例 —— 复数的运算
用,+”、,-”能够实现复数的加减运算吗？
实现复数加减运算的方法
—— 重载,+”、,-”运算符运算符重载
C++语言程序设计 湖南科技大学
6
运算符重载的实质
运算符重载是对已有的运算符赋予多重含义
必要性
– C++中预定义的运算符其运算对象只能是基本数据类型，而不适用于用户自定义类型（如类）
实现机制
– 将指定的运算表达式转化为对运算符函数的调用，运算对象转化为运算符函数的实参。
– 编译系统对重载运算符的选择，遵循函数重载的选择原则。
运算符重载
C++语言程序设计 湖南科技大学
7
运算符重载规则和限制
可以重载 C++中除下列运算符外的所有运算符：
.,*,,?,sizeof
只能重载 C++语言中已有的运算符，
不可臆造新的。
不改变原运算符的优先级和结合性。
不能改变操作数个数。
经重载的运算符，其操作数中至少应该有一个是自定义类型。
C++语言程序设计 湖南科技大学
8
两种形式
重载为类成员函数。
重载为友元函数。
运算符重载
C++语言程序设计 湖南科技大学
9
运算符函数
声明形式函数类型 operator 运算符（形参）
{
......
}
重载为类成员函数时参数个数 =原操作数个数 -1（后置 ++,--除外）
重载为友元函数时 参数个数 =原操作数个数,
且至少应该有一个自定义类型的形参。
运算符重载
C++语言程序设计 湖南科技大学
10
运算符成员函数的设计
双目运算符 B
– 如果要重载 B 为类成员函数，使之能够实现表达式 oprd1 B oprd2，其中 oprd1 为 A
类对象，则 B 应被重载为 A 类的成员函数，
形参类型应该是 oprd2 所属的类型。
– 经重载后，表达式 oprd1 B oprd2 相当于
oprd1.operator B(oprd2)
运算符重载
C++语言程序设计 湖南科技大学
11
运算符重载例 8-1
将,+”,,-” 运算重载为复数类的成员函数。
规则,
– 实部和虚部分别相加减。
操作数,
– 两个操作数都是复数类的对象。
#include<iostream>
using namespace std;
class complex //复数类声明
{
public,//外部接口
complex(double r=0.0,double i=0.0){real=r;imag=i;}
//构造函数
complex operator + (complex c2); //+重载为成员函数
complex operator - (complex c2); //-重载为成员函数
void display(); //输出复数
private,//私有数据成员
double real; //复数实部
double imag; //复数虚部
};
12
complex complex::
operator +(complex c2) //重载函数实现
{
complex c;
c.real=c2.real+real;
c.imag=c2.imag+imag;
return complex(c.real,c.imag);
}
13
complex complex::
operator -(complex c2) //重载函数实现
{
complex c;
c.real=real-c2.real;
c.imag=imag-c2.imag;
return complex(c.real,c.imag);
}
14
void complex::display()
{ cout<<"("<<real<<","<<imag<<")"<<endl; }
int main() //主函数
{ 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();
}
15
程序输出的结果为：
c1=(5,4)
c2=(2,10)
c3=c1-c2=(3,-6)
c3=c1+c2=(7,14)
16
C++语言程序设计 湖南科技大学
17
运算符成员函数的设计
前置单目运算符 U
– 如果要重载 U 为类成员函数，使之能够实现表达式 U oprd，其中 oprd 为 A类对象，则 U 应被重载为 A 类的成员函数，
无形参。
– 经重载后，
表达式 U oprd 相当于 oprd.operator U()
运算符重载
C++语言程序设计 湖南科技大学
18
运算符成员函数的设计
后置单目运算符 ++和 --
– 如果要重载 ++或 --为类成员函数，使之能够实现表达式 oprd++ 或 oprd--,其中 oprd 为 A类对象，则 ++或 -- 应被重载为 A 类的成员函数，且具有一个 int
类型 形参 。
– 经重载后，表达式 oprd++ 相当于
oprd.operator ++(0)
运算符重载
C++语言程序设计 湖南科技大学
19
例 8-2
运算符前置 ++和后置 ++重载为时钟类的成员函数。
前置单目运算符，重载函数没有形参，
对于后置单目运算符，重载函数需要有一个整型形参。
操作数是时钟类的对象。
实现时间增加 1秒钟。
运算符重载
//8_2.cpp
#include<iostream>
using namespace std;
class Clock //时钟类声明
{
public,//外部接口
Clock(int NewH=0,int NewM=0,int NewS=0);
void ShowTime();
Clock& operator ++(); //前置单目运算符重载
Clock operator ++(int); //后置单目运算符重载
private,//私有数据成员
int Hour,Minute,Second;
};
20
Clock& Clock::operator ++() //前置单目运算符重载函数
{ Second++;
if(Second>=60)
{ Second=Second-60;
Minute++;
if(Minute>=60)
{
Minute=Minute-60;
Hour++;
Hour=Hour%24;
}
}
return *this;
}
21
//后置单目运算符重载
Clock Clock::operator ++(int)
{ //注意形参表中的整型参数
Clock old=*this;
++(*this);
return old;
}
22
//其它成员函数的实现略
int main()
{
Clock myClock(23,59,59);
cout<<"First time output:";
myClock.ShowTime();
cout<<"Show myClock++:";
(myClock++).ShowTime();//后置单目运算
cout<<"Show ++myClock:";
(++myClock).ShowTime();//前置单目运算符
}
23
程序运行结果为：
First time output,23:59:59
Show myClock++,23:59:59
Show ++myClock,0:0:1
24
C++语言程序设计 湖南科技大学
25
运算符友元函数的设计
如果需要重载一个运算符，使之能够用于操作某类对象的私有成员，可以将此运算符重载为该类的友元函数。
函数的形参代表依次左至右次序排列的各操作数。
后置单目运算符 ++和 --的重载函数，
形参列表中要增加一个 int，但不必写形参名。
运算符重载
C++语言程序设计 湖南科技大学
26
运算符友元函数的设计
双目运算符 B重载后，
表达式 oprd1 B oprd2
等同于 operator B(oprd1,oprd2 )
前置单目运算符 B重载后，
表达式 B oprd
等同于 operator B(oprd )
后置单目运算符 ++和 --重载后，
表达式 oprd B
等同于 operator B(oprd,0 )
运算符重载
C++语言程序设计 湖南科技大学
27
例 8-3
将 +,-（双目）重载为复数类的友元函数。
两个操作数都是复数类的对象。
运算符重载
#include<iostream>
using namespace std;
class complex //复数类声明
{
public,//外部接口
complex(double r=0.0,double i=0.0)
{ real=r; imag=i; } //构造函数
friend complex operator + (complex c1,complex c2);
//运算符 +重载为友元函数
friend complex operator - (complex c1,complex c2);
//运算符 -重载为友元函数
void display(); //显示复数的值
private,//私有数据成员
double real;
double imag;
};
28
complex operator +(complex c1,complex c2)
//运算符重载友元函数实现
{ return
complex(c2.real+c1.real,c2.imag+c1.imag);
}
complex operator -(complex c1,complex c2)
//运算符重载友元函数实现
{ return
complex(c1.real-c2.real,c1.imag-c2.imag);
}
// 其他函数和主函数同例 8-1
29
C++语言程序设计 湖南科技大学
30
静态绑定与动态绑定
绑定
– 程序自身彼此关联的过程，确定程序中的操作调用与执行该操作的代码间的关系。
静态绑定
– 绑定过程出现在编译阶段，用对象名或者类名来限定要调用的函数。
动态绑定
– 绑定过程工作在程序运行时执行，在程序运行时才确定将要调用的函数。
C++语言程序设计 湖南科技大学
35
虚函数
虚函数是动态绑定的基础。
是非静态的成员函数。
在类的声明中，在函数原型之前写 virtual。
virtual 只用来说明类声明中的原型，不能用在函数实现时 (即,函数实现前面不能有 virtual )。
具有继承性，基类中声明了虚函数，派生类中无论是否说明，同原型函数都自动为虚函数。
本质：不是重载声明而是覆盖。
调用方式：通过基类指针或引用，执行时会根据 指针指向的对象的类,决定调用哪个函数。
虚函数
C++语言程序设计 湖南科技大学
36
例 8-4
#include <iostream>
using namespace std;
class B0 //基类 B0声明
{public,//外部接口
virtual void display() //虚成员函数
{cout<<"B0::display()"<<endl;}
};
class B1,public B0 //公有派生
{ public:
void display() { cout<<"B1::display()"<<endl; }
};
class D1,public B1 //公有派生
{ public:
void display() { cout<<"D1::display()"<<endl; }
};
虚函数
void fun(B0 *ptr) //普通函数
{ ptr->display(); }
int main() //主函数
{ B0 b0,*p; //声明基类对象和指针
B1 b1; //声明派生类对象
D1 d1; //声明派生类对象
p=&b0;
fun(p); //调用基类 B0函数成员
p=&b1;
fun(p); //调用派生类 B1函数成员
p=&d1;
fun(p); //调用派生类 D1函数成员
}
运行结果：
B0::display()
B1::display()
D1::display()
37
C++语言程序设计 湖南科技大学
38
虚析构函数何时需要虚析构函数？
当你可能通过基类指针删除派生类对象时
如果你打算允许其他人通过基类指针调用对象的析构函数（通过 delete这样做是正常的），并且被析构的对象是有重要的析构函数的派生类的对象，
就需要让基类的析构函数成为虚拟的。
虚函数
C++语言程序设计 湖南科技大学
39
例 8-5
#include <iostream>
using namespace std;
class Base
{ public,//外部接口
~Base(){ cout<< "Base destructor\n";}
};
class Derived,public Base //公有派生
{ public:
Derived();
~Derived();
private:
int *i_pointer;
};
C++语言程序设计 湖南科技大学
40
Derived::Derived()
{ i_pointer=new int(0); }
Derived::~Derived()
{
cout<< "Derived destructor\n";
delete i_pointer;
}
void fun(Base* b)
{ delete b; }
int main()
{
Base *b=new Derived();
fun(b);
}
运行结果：
Base destructor
C++语言程序设计 湖南科技大学
41
避免上述错误的有效方法是声明析构函数为虚函数：
class Base
{ public,//外部接口
virtual ~Base(){ cout<< "Base destructor\n";}
};
运行结果：
Derived destructor
Base destructor
C++语言程序设计 湖南科技大学
42
抽象类带有纯虚函数的类称为抽象类,
class 类名
{
virtual 类型 函数名 (参数表 )=0;
//纯虚函数
...
}
纯虚函数与抽象类
C++语言程序设计 湖南科技大学
43
抽象类纯虚函数与抽象类
作用
– 抽象类为抽象和设计的目的而声明，将有关的数据和行为组织在一个继承层次结构中，保证派生类具有要求的行为。
– 对于暂时无法实现的函数，可以声明为纯虚函数，
留给派生类去实现。
注意
– 抽象类只能作为基类来使用。
– 不能声明抽象类的对象。
– 构造函数不能是虚函数，析构函数可以是虚函数。
C++语言程序设计 湖南科技大学
44
例 8-6
纯虚函数与抽象类
#include <iostream>
using namespace std;
class B0 //抽象基类 B0声明
{ public,//外部接口
virtual void display( )=0; //纯虚函数成员
};
class B1,public B0 //公有派生
{ public:
void display(){cout<<"B1::display()"<<endl;} //虚成员函数
};
class D1,public B1 //公有派生
{ public:
void display(){cout<<"D1::display()"<<endl;} //虚成员函数
};
void fun(B0 *ptr) //普通函数
{ ptr->display(); }
int main() //主函数
{ B0 *p; //声明抽象基类指针
B1 b1; //声明派生类对象
D1 d1; //声明派生类对象
p=&b1;
fun(p); //调用派生类 B1函数成员
p=&d1;
fun(p); //调用派生类 D1函数成员
}
运行结果：
B1::display()
D1::display()
45
C++语言程序设计 湖南科技大学
46
小结与复习建议
主要内容
– 多态性的概念、运算符重载、虚函数、
纯虚函数、抽象类
达到的目标
– 理解多态的概念，学会运用多态机制。
实验任务
– 实验八
