在C++中,使用虚函数机制,父类与子类的同名操作,主要标记上virtual,则该操作便具有多态性。
//-----------student.h--------------
#ifndef STUDENT__H
#define STUDENT__H
#include <iostream>
class Student
{
private:
std::string name;
int semesterHours;
double average;
public:
enum StudentType{STUDENT,GRADUATESTUDENT}; //定义反应类型的的数据成员,通过这里来区分 是Student的对象还是GraduateStudent的对象
StudentType type;
Student(std::string pN = "noName")
{
//type = STUDENT; //Student对象的标志
name = pN;
semesterHours = 0;
average = 0;
}
virtual void calcTuition(){std::cout<<"Student tuition calculation."<<std::endl;}
};
#endif
//----------graduatestudent.h----------
#ifndef GRADUATESTUDENT__H
#define GRADUATESTUDENT__H
#include "student.h"
class Advisor
{
private:
int noOfMeeting;
};
class GraduateStudent : public Student //继承 Student
{
private:
Advisor advisor;
int qualifierGrade;
public:
GraduateStudent(std::string pN = "noName")
{
//type = GRADUATESTUDENT; //GraduateStudent 对象的标志
qualifierGrade = 0;
Student::Student(pN); //父类重载 传递 name
}
virtual void calcTuition(){std::cout<<"GraduateStudent Tuition calculation."<<std::endl;}
};
#endif
//---------main.cpp------------
#include "student.h"
#include "graduatestudent.h"
using namespace std;
//void fn(Student &s)
//{
// switch(s.type)
// {
// case Student::STUDENT: //通过构造函数中的type来区分对象的类型
// s.calcTuition();
// break;
// case GraduateStudent::GRADUATESTUDENT: //通过构造函数中的type来区分对象的类型
//
// GraduateStudent &ss = static_cast<GraduateStudent &>(s); //这个地方用的 “很妙”
// ss.calcTuition();
// //(static_cast<GraduateStudent>s).calcTuition(); //错
// //GraduateStudent(s).calcTuition(); //错
// break;
// }
//}
void fn(Student &s)
{
s.calcTuition();
}
int main(int argc,char **argv)
{
Student ds("Lo lee undergrade");
GraduateStudent gs("Jack");
fn(ds); //通过对象类型做出不同反应
fn(gs); //通过对象类型做出不同反应
return 0;
}
Student tuition calculation.
GraduateStudent Tuition calculation.
请按任意键继续. . .
注意:
仅仅对于对象的指针和引用的间接访问,才会发生多态。
如果是引发实际复制动作的传递,则子类对象完全变成父类对象了,这时候,便不会有悬念了,即不会有多态了。
void fn(Student s); //传值
void gn()
{
Student s;
GraduateStudent gs;
fn(s);
fn(gs); //无多态可言
}
1