通过 虚函数 来实现多态

在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