通过 虚函数 来实现多态

在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