c++虚函数和抽象类学习一

函数绑定

    函数绑定就是函数的入口地址同函数的调用相联系的过程。绑定分为静态绑定和动态绑定两种形式，二者区别在于：静态绑定在程序编译时就已经完成函数绑定，而动态绑定是在程序运行时才完成需要的函数绑定。传统的面向过程的C语言仅支持静态绑定，而现在的C++、C#、java等面向对象的语言则支持动态绑定，但他们也支持静态绑定。

分析下列程序的输出结果是什么？

#include<iostream>
#include<stdio.h>
using namespace std;
class Student
{
protected:
 int no;
 char name[10];
 int fee1,fee2,fee3,fee4,fee;
public:
 void calfee()
 {
  cout<<"学号：";
  cin>>no;
  cout<<"姓名：";
  cin>>name;
  fee1=4800;
  fee2=1100;
  fee3=400;
  fee4=200;
  fee=fee1+fee2+fee3+fee4;
 }
 void disp()
 {
  cout<<"学费："<<fee1<<endl;
  cout<<"住宿费："<<fee2<<endl;
  cout<<"书报费："<<fee3<<endl;
  cout<<"其他："<<fee4<<endl;
  cout<<"总费用："<<fee<<endl;
 }
};
class Graduate:public Student
{
public:
 void calfee()
 {
  cout<<"学号：";
  cin>>no;
  cout<<"姓名：";
  cin>>name;
  fee1=1100;
  fee2=400;
  fee3=200;
  fee=fee1+fee2+fee3;
 }
 void disp()
 {
  cout<<"住宿费："<<fee1<<endl;
  cout<<"书报费："<<fee2<<endl;
  cout<<"其他："<<fee3<<endl;
  cout<<"总费用:"<<fee<<endl;
 }
};
void fn(Student &x)
{
 x.calfee();
 x.disp();
}
void main()
{
 Student s1;
 Graduate s2;
 cout<<"大学生收费"<<endl;
 fn(s1);
 cout<<"研究生收费"<<endl;
 fn(s2);
}

程序的运行结果为

观察实验结果，我们发现两次的输出的结果都是6500。在主函数中，虽然s2被声明为Graduate对象。但是由于函数fn()是静态绑定，即它在程序编译时就将它的参数绑定为Student类型。我们可以将其理解为硬性支持。

下面我们再看一个例子：

#include<iostream>
#include<stdio.h>
using namespace std;
class Student
{
protected:
 int no;
 char name[10];
 int fee1,fee2,fee3,fee4,fee;
public:
 virtual void calfee()                       //虚函数
 {
  cout<<"学号：";
  cin>>no;
  cout<<"姓名：";
  cin>>name;
  fee1=4800;
  fee2=1100;
  fee3=400;
  fee4=200;
  fee=fee1+fee2+fee3+fee4;
 }
 virtual void disp()                            //虚函数
 {
  cout<<"学费："<<fee1<<endl;
  cout<<"住宿费："<<fee2<<endl;
  cout<<"书报费："<<fee3<<endl;
  cout<<"其他："<<fee4<<endl;
  cout<<"总费用："<<fee<<endl;
 }
};
class Graduate:public Student   //由Student类派生出的Graduate类
{
public:
 void calfee()
 {
  cout<<"学号：";
  cin>>no;
  cout<<"姓名：";
  cin>>name;
  fee1=1100;
  fee2=400;
  fee3=200;
  fee=fee1+fee2+fee3;
 }
 void disp()
 {
  cout<<"住宿费："<<fee1<<endl;
  cout<<"书报费："<<fee2<<endl;
  cout<<"其他："<<fee3<<endl;
  cout<<"总费用:"<<fee<<endl;
 }
};
void fn(Student &x)         //普通函数，形参为Student类对象的引用
{
 x.calfee();
 x.disp();
}
void main()
{
 Student s1;
 Graduate s2;
 cout<<"大学生收费"<<endl;
 fn(s1);
 cout<<"研究生收费"<<endl;
 fn(s2);
}

结果为：

这个结果为6500和1700。

因为这个程序中的Student类的函数被声明为virtual类型。该类型将函数声明为虚函数。虚函数支持动态绑定，它在程序运行过程中才去绑定它的类对象。

虚函数是动态绑定的基础，它是引入派生概念之后用来表现基类和派生类成员函数之间的一种关系。虚函数在基类中定义，它是一种成员函数，而且是动态的成员函数。它允许在程序运行时，该虚函数在基类和派生对象之间根据调用函数的对象的类型进行加载。

    虚函数的声明：virtual 函数类型 函数名（参数表）

其中用关键词virtual声明的函数称为虚函数。如果某类中的一个成员函数被声明为虚函数，这就意味着该类成员函数在派生类中可能有不同的实现。当使用这个成员函数操作指针或引用标示对象来调用虚函数，对该成员函数进行动态绑定方式，即在运行时进行关联或束定。

动态绑定只能通过指针或引用标识对象来调用虚函数。如果采用一般类型的标识对象来调用虚函数，则将采用静态绑定方式调用虚函数。

C++动态绑定的处理方式仍能实现静态类型检查，换句话说，函数参数类型的错误在编译阶段能够检查出来。

多继承中的虚函数

在多继承中，由于派生类是由多个基类派生而来的，这些基类中既有虚函数，也有非虚拟函数的普通函数，因此虚函数的使用不像单继承那么简单。

看一个例子：

#include<iostream>
#include<stdio.h>
using namespace std;
class A
{
public:
 virtual void f()
 {
  cout<<"class A"<<endl;
 }
};
class B
{
public:
 void f()
 {
  cout<<"class B"<<endl;
 }
};
class C:public A,public B
{
public :
 void f()
 {
  cout<<"class C"<<endl;
 }
};

void main()
{
 A a,*p1;         //定义对象a,对象指针p1
 B b,*p2;         //定义对象b,对象指针p2
 C c;             //定义对象c
 p1=&a;
 p1->f();         //A类型的对象指针访问A的函数
 p2=&b;          
 p2->f();         //B类型的对象指针访问B的函数
 p1=&c;
 p1->f();         //指向C类对象的指针首先访问基类的函数，因为基类的函数是虚函数，支持动态绑定。
 p2=&c;
 p2->f();         //指向C类对象的指针首先访问基类的函数，但遭拒，因为基类的函数不是虚函数，并不支持动态绑定
}
//指向派生类对象的指针首先检查基类对象的函数，看基类函数是否为虚函数，
//如果是，则访问其上的派生类的同名函数,如果不是，访问基类同名函数。

//虚函数的好处就是可以为一个基类定义一个虚函数，然后该基类的众多派生类中定义同名的函数，当指向派生类的基类指针访问同名函数时，就可以根据需要调用相应派生类的函数

程序运行结果为：