c++学习笔记十五

虚函数和多态性

使用基类指针,示例代码如下(从Box派生两个类)
class Carton:public Box{

};
class ToughPack:public Box{

};


Carton aCarton(10.0,10.0,5.0);
Box * pBox=& aCarton;

ToughPack hardcase(12.0,8.0,4.0);
pBox=&hardcase;

有如下语句：pBox()->volume; 此时如pBox包含的是Carton的对象地址，那


么它指向的就是Carton对象的函数,同理hardcase也一样



调用继承的函数


头文件Box.h
#ifndef BOX_H
#define BOX_H
================ 基类=========================================
class Box{
//构造器
public:
Box(double lengthValue=1.0,double widthValue=1.0,double


heightValue=1.0);

//成员函数
void showVolume() const;
double volume() const;


//成员变量
protected:
double length;
double width;
double height;
};
#endif
==================================================================
实现文件Box.cpp
#include "Box.h"
#include <iostream>
using std::cout;
using std::endl;

//构造函数
Box::Box(double lvalue,double wvalue,double hvalue):length


(lvalue),width(wvalue),height(hvalue){}

void Box::showVolume() const{
cout<<"Box usable volume is "<<volume()<<endl;
}

double Box::volume() const{
return length*width*height;
}
=================派生类============================================
头文件ToughPack.h
#ifndef TOUGHPACK_H
#define TOUGHPACK_H

#include "Box.h"

class ToughPack:public Box{
public:
ToughPack(double lengthValue,double widthValue,double


heightValue);
double volume() const;
}
===================================================================
实现文件ToughPack.cpp
#include "ToughPack.h"

ToughPack::ToughPack(double lval,double wval,double hval):Box


(lval,wval,hval){}
double ToughPack::volume() const{
return 0.85*length*width*height;
}
====================================================================
使用继承的函数
#include <iostream>
#include "Box.h"
#include "ToughPack.h"
using std::cout;
using std::endl;

int main(){
Box myBox(20.0,30.0,40.0);
ToughPack hardcase(20.0,30.0,40.0);

cout<<endl;
myBox.showVolume();//调用基类函数
hardcase.showVolume();//调用派生类函数

return 0;
}
如果想直接调用ToughPack中的valume()方法,示例代码如下：
cout<<"hardcase volume is"<<hardcase.volume()<<endl;
Box *pBox =&hardcase;
cout<<"hardcase volume through pBox is"<<pBox->volume()<<endl;

虚函数
一个基类中如果定义了虚函数,那么在派生于这个类的任何类，该函数都是动态


绑定的.(virtual) 使用对象的引用或指针都可以调用虚函数
注： 每个派生类都可以执行虚函数的自有版本
示例代码
class Box {
//构造器
public:
Box(double lenthValue=1.0,double widthValue=1.0,double


heightValue=1.0);

void showVolume() const;

//虚函数
virtual double volume() const;

//成员变量
protected:
double length;
double width;
double lenght;
}
=================================================================
Carton.h头文件
#ifndef CARTON_H
#define CARTON_H
#include <string>
#include "Box.h"
using std::string;

class Carton:public Box{
//构造函数
pulbic:
Carton(double lv,double wv,double hv,string


material="Cardboard");
//副本构造成器
Carton(const Carton & aCarton);

//析构函数
double volume() const;

//成员变量
private:
string * pMaterial;
};
#endif
==========================================================
实现文件Carton.cpp
#include "Carton.h"
Carton::Carton(double lv,double wv,double hv,string material):Box


(lv,wv,hv){
pMaterial=new string(material);
}
Carton::Carton(const Carton & aCarton){
length=aCarton.width;
width=aCarton.height;
height=aCarton.width;
pMaterial=new string (* aCarton,pMaterial);
}

Carton::~Carton(){
delete pMaterial;
}

double Carton::volume() const{
double vol-(length-0.5)*(width-0.5)*(height-0.5);
return vol>0.0?vol:0.0;
}


=============================================================
调用访函数的示例代码如下：
#include <iostream>
#include "Box.h"
#include "ToughPack.h"
#include "Carton.h"
using std::cout;
using std::endl;

int main(){
Box myBox(20.0,30.0,40.0);
ToughPack hardcase(20.0,30.0,40.0);
Carton aCarton(20.0,30.0,40.0);

//显示三个对象的体积
cout<<endl;
myBox.showVolume();
hardcase.showVolume();
aCarton.showVolume();
cout<<endl;

pBox=& hardcase;
cout<<"hardcase volume through pBox is"<<pBox->volume()<<endl;
pBox->showVolume();
cout<<endl;

pBox=& aCarton;
cout<<"aCarton volume through pBox is"<<pBox->volume()<<endl;
pBox->showVolume();


return 0;
}

虚函数中的默认参数值
如果在基类的虚函数中使用默认参数，在通过基类指针调用该函数时,只会


使用基类中的默认参数


头文件Box.h
#ifndef BOX_H
#define BOX_H

class Box {
//构造器
public:
Box(double lenthValue=1.0,double widthValue=1.0,double


heightValue=1.0);

void showVolume() const;

//虚函数
virtual double volume(const int i=5) const;

//成员变量
protected:
double length;
double width;
double lenght;
};
#endif


====================================================================
实现文件Box.cpp
#include "Box.h"
#include <iostream>
using std::cout;
using std::endl;

//构造函数
Box::Box(double lvalue,double wvalue,double hvalue):length


(lvalue),width(wvalue),height(hvalue){}

void Box::showVolume() const{
cout<<"Box usable volume is "<<volume()<<endl;
}

//使用默认参数
double Box::volume(const int i) const{
cout<<"Parameter"<<i<<endl;
return length*width*height;
}
====================================================================
派生类 头文件ToughPack.h
#ifndef TOUGHPACK_H
#define TOUGHPACK_H

#include "Box.h"

class ToughPack:public Box{
//构造成器
public:
ToughPack(double lengthValue,double widthValue,double


heightValue);
//虚函数
virtual double volume(const int i=500) const;
};
#endif
===================================================================

实现文件ToughPack.cpp
#include "ToughPack.h"
#include <iostream>
using std::cout;
using std::endl;
ToughPack::ToughPack(double lVal,double wVal,double hVal):Box


(lVal,wVal,hVal){}
double ToughPack::volume() const{
cout<<"Parameter"<<i<<endl;
return 0.85*length*width*height;
}
=====================================================================
调用时
#include <iostream>
#include "Box.h"
#include "ToughPack.h"
#include "Carton.h"
using std::cout;
using std::endl;

int main(){
Box myBox(20.0,30.0,40.0);
ToughPack hardcase(20.0,30.0,40.0);
Carton aCarton(20.0,30.0,40.0);

cout<<endl;
myBox.showVolume();
hardcase.showVolume();
aCarton.showVolume();
cout<<endl;

cout<<"hardcase volume is"<<hardcase.volume()<<endl;


Box pBox=& myBox;
cout<<"myBox volume through pBox is"<<pBox->volume()<<endl;
pBox->showVolume();
cout<<endl;


pBox=& hardcase;
cout<<"hardcase volume through pBox is"<<pBox->volume()<<endl;
pBox->showVolume();
cout<<endl;

pBox=& aCarton;
cout<<"aCarton volume through pBox is"<<pBox->volume()<<endl;
pBox->showVolume();

return 0;

}




通过引用来来调用虚函数
对虚函数的引用
#include <iostream>
#include "Box.h"
#include "ToughPack.h"
#include "Carton.h"
using std::cout;
using std::endl;

void showVolume(const Box & rBox);

int main(){
Box myBox(20.0,30.0,40.0);
ToughPack hardcase(20.0,30.0,40.0);
Carton aCarton(20.0,30.0,40.0);

cout<<endl;
showVolume(myBox);
showVolume(hardcase);
showVolume(aCarton);

return 0;
}

void showVolume(const Box & rBox){
rBox.showVolume();
}


调用虚函数的基类版本 示例代码如下:
通过派生类对像的指针或引用虚函数的派生类版本
Carton aCarton(40.0,30.0,20.0)
Box* pBox=&aCarton;
计算Carton对像的总体积损失:
double difference=pBox->Box::volume()->pBox->volume();


pBox->Box::volume()

在指针和类对像之间的转换
如果程序包含派生类的指针,就可以把指针隐式转换为基类指针,(可以是直接基


类指针，也可以是间接基类指针)
例如：
Carton * pCarton=new Carton(30,40,10);
可以把这个隐式指针转换为Carton的直接基类指针,
Box * pBox=pCarton;
还可以把派生类的隐式指针转换为间接基类的指针,示例化码如下：
CerealPace继承Carton,carton继承Box
Box* pBox=pCerealPack;//把pCerealPack中的地址从“指向CerealPack”的指


针类型转换为"指向Box"的指针类型
如果要指定显示转换，可以使用static_case<>()运算符
Box* pBox=static_case<Box*>(pCerealPack);






动态强制转换 (只能应用于多态类类型的指针和引用,即至少包含一个虚函数的


类类型)
在使用期间，要指定动态强制转换,应使用dynamic_case<>()运算符
动态转换指针
动态制转换有两种类型:
一种是沿着类层次结构向下进行强制转换(从直接或间接基类的指针转换为派


生类型的指针,称为downcast)
示例代码如下：
目标类型 要强制转换为新类型的表达式
Carton * pCarton=dynamic_cast<Carton*> (pBox);
注：Carton和Box必须包含虚函数
另一种是跨类层次的强制转换,称为crosscast
Contents* pContents=dynamic_cast<Contents*>(pBox);
注： Contents和Box类都必须是多态性的

假定一个Box对象指向某个对象，如果想调用Carton类的一个非虚函数
基类指针只允许调用派生类的虚函数，而dynamic_cast<>()运算符可以调用


非虚函数
示例代码：如果想调用Carton类的一个非虚函数在员surface()方法
dynamic_cast<Carton*>(pBox)->surface();
注：这样作的前提是确保pBox指向Carton对象或指向Carton作为基类的对象
正确写法：
if(Carton* pCarton=dynamic_cast<Carton*>(pBox)){
pCarton->surface();
}

注：如果要强制转换的指针类型是const,则目标类型也必须是const,
如果把const指针转换为非const类型指针,就必须使用const_cast<>()


转换引用(函数的引用参数)
示例人代码如下：
double doThat(Box & rBox){
Carton& rCarton=dynamic_cast<Carton&>(rBox);
}


多态性的成本 ( 虚函数的调用需要额外和开销)
简单的说包含相同数据成员,含有虚函数的类要比没有的类占用的内存要多
内存使用多的原因：在创建多态类的对象，要在对象中创建一个特殊指针（用


于调用对象中的虚函数）
纯虚函数(类似于接口-所有的成员都有是抽象成员)
示例代码如下：
class Shape{
public:
virtual void draw() const=0;
virtual void move(const Point& newPosition)=0;

protected:
Point position;
Shape(const Point& shapePosition):position(shapePosition){}
};


抽象类(抽象类的指针或引用可以用作参数或返回类型)

抽象类的构造函数可以在派生类的构造函数的初始化列表中调用(一般为


protected类型)
示例代码：声明一个新类，它把shape类作为基类
class Circle:public Shape{
public :
Circle(Point center,double circleRadius):Shape(),radius


(circleRadius){}
virrual void draw() const{
cout<<"Circle center"<<position<<"radius"<<radius<<endl;
}
virrual void move(const Point& newCenter){
position=newCenter;
}
private:
double radius;
}
注： Circle类定义了draw()和move()函数, 如果没有定义这两个方法中的


任何一个，Circle就是一个构造类
如果类中有一个纯虚函数，该类就是抽象类,派生类必须定义基类中的每


个纯虚函数，否则派生类也是一个抽象类,当然抽象类还可以包含非纯虚函数


示例代码：
class Box{
public:
Box(double lengthValue=1.0,double widthValue=1.0,double


heightValue=1.0);
protected:
double length;
double width;
double height;
};

#include<iostream>
#include "Box.h"
#include "ToughPack.h"
#include "Carton.h"
using std::count;
using std::endl;

int main(){
cout<<endl;

ToughPack hardcase(20.0,30.0,40.0);
Box* pBox=&hardcase;
cout<<"Volume of hardcase is"<<pBox->volume()<<endl;


Carton aCarton(20.0,30.0,40.0);
pBox=&aCarton;
cout<<"volume of aCarton is"<<pBox->volume()<<endl;

return 0;
}

用接口的抽象类 (只有包含一个纯虚接口的抽象类可以用于定义标准类接口)

间接的抽象类
多级继承 示例代码
vessel为Box的基类
头文件如下
#ifndef VESSEL_H
#define VESSEL_H

class Vessel{
public:
virrual double volume() const=0;// 虚函数
};
#endif

Box类的头文件为:
#ifndef BOX_H
#define BOX_H
#include "Vessel.h"
class Box:public Vessel{
public:
Box(double lengthValue=1.0,double widthValue=1.0,double


heightValue=1.0);
virtual double volume() const;//不是纯虚状态
protected:
double length;
double width;
double height;
};
#endif

实现文件Box.cpp
double Box::volume() const{
return length * width* height;
}

另一个vessel中另一个派生类can,头文件can.h
#ifndef CAN_H
#define CAN_H

#inclued "Vessel.h"
class Can:pulbic Vessel{
public :
Can(double canDiameter,double canHeight);
virtual double volume() const;//
protected:
double diameter;
double height;
static const double pi;//虚函数
};
#endif
实现文件can.cpp
#include "Can.h"
Can::Can(double canDiameter,double canHeight):diameter


(canDiameter),height(canHaight){}

double Can:volume() const{
return pi* diameter*diameter*height/4;
}
const double Can::pi=3.1415926;




测试主函数
#include <iostream>
#include "Box.h"
#include "ToughPack.h"
#include "Carton.h"
#include "Can.h"

using std::cout;
using std::endl;


int main(){
//初始化容器
Box aBox(40,30,20);
Can aCan(10,3);
Carton aCarton(40,30,20);
ToughPack hardcase(40,30,20);


Vessel* pVessels[]={&aBox,&aCan,&aCarton,&hardcase};

cout<<endl;
for(int i=0;i<sizeof pVessels/sizeof(pVessels[0]);i++){
cout<<"Volume is"<<pVessels[i]->value<<endl;
}
return 0;
}

通过指针释放对象
示例代码如下：
在vesel类的头文件中添
class Vassel{
public:
virtual double volume() const=0;// 虚函数
~Vessel();//析构函数
}
实现文件中添加如下代码
#include <iostream>
#include "Vessel.h"

Vessel::~Vessel(){
sed::cout<<"Vessel destructor"<<std::endl;
}
在派生类加添加相同的输出一句

测试主函数如下：
#include <iostream>
#include "Box.h"
#include "ToughPack.h"
#include "Carton.h"
#include "Can.h"

using std::cout;
using std::endl;


int main(){
//初始化容器
Box aBox(40,30,20);
Can aCan(10,3);
Carton aCarton(40,30,20);
ToughPack hardcase(40,30,20);


Vessel* pVessels[]={&aBox,&aCan,&aCarton,&hardcase};

cout<<endl;
for(int i=0;i<sizeof pVessels/sizeof(pVessels[0]);i++){
cout<<"Volume is"<<pVessels[i]->value<<endl;
}
//释放资源
for(int i=0;i<sizeof pVessels/sizeof(pVessels[0]);i++){
delete pVessels[i];
}
return 0;
}


结果是几个类在释放资源时都调用基类Vessel destructor的析构函数


虚析构函数
在析构函数声明中添加关键字virtual
调用虚拟析构函数,示例代码如下:
class Vessel{
public :
virtual double volume() const=0;//虚函数
virtual ~vessel();//虚析构函数
};



在运行期间标识类型
检查指针指向类型 （typeid()运算符，需在头文件中包含<typeinfo>


）
if(typeid(* pVessel)==typeid(Carton)){
cout<"Pointer is type Carton"<<endl;
}else{
cout<"Pointer is not type Carton"<<endl;
}





类成员的指针
数据成员指针 它包含类成员的地址，仅在与类对象组合使用时，才指向内


存的某个位置
示例代码如下：
class Box{
public :
Box( Box(double lenthValue=1.0,double


widthValue=1.0,double heightValue=1.0);
void showVolume() const;
public : //原始状态为protected
double length;
double width;
double height;
}

//定义一个指针
double Box::* pData;
//注创建同意词的语名
typedef double Box:: * pBoxMember;//pBoxMember替代double Box::*
//下面的语句把类成员width的地址赋于这个指针
pData=&Box::width;

"成员指针"选择运算符
成员指针总是要和对象、对象的引用或对象的指针一起使用
示例代码如下：
Box myBox(20.0,30.0,40.0);
调用myBox的width成员
myBox.*pData




应用Box指针
Box* pBox=&myBox;
通过指针访问myBox 中的数据成员
pBox->*pData//此处用到间接成员指针->*

使用成员指针，示例代码
#include <iostream>
#include "Box.h"
#include "ToughPack.h"
#include "Carton.h"

using std::cout;
using std::endl;

typedef double Box::* pBoxMember;
int main(){
//初始化三个容器
Box myBox(20.0,30.0,40.0);
ToughPack hardcase(35.0,45.0,55.0);
Carton aCarton(48.0,58.0,68.0);
//使用成员指针，指向成员长度
pBoxMember pData=&Box::length;

cout<<endl;

cout<<"Length member of myBox is"<<myBox.*pData<<endl;
pData=&Box::width;//指向成员宽度


cout<<"width member of myBox is"<<myBox.*pData<<endl;
pData=&Box::height;//指向成员高度


cout<<"height member of myBox is"<<myBox.*pData<<endl;
cout<<"height member of hardcase is"<<hardcase.*pData<<endl;
cout<<"height member of aCarton is"<<aCarton.*pData<<endl;

//利指针访问成员指针中的成员
Box* pBox=&myBox;

cout<<"height memeber myBox is"<<pBox->*pData<<endl;
pBox=&hardcase;

cout<<"height memeber hardcase is"<<pBox->*pData<<endl;
cout<<endl;
return 0;
}