虚函数virtual实验（PS：需注意函数的重写与隐藏）

开始

 一定要注意“静态联翩 ”和“ 动态联编 ”的区别

1.未添加virtual时，将一直调用的是基函数的方法                                                                     

 ——   通过指针、引用调用

#include <iostream>
using namespace std;

class Base1
{
 public:
	 void display()const
	 {
		 cout<<"Base1::display()"<<endl;
	 }
};
class Base2 : public Base1
{	
 public:
	void display()const
	{
		cout<<"Base2::display()"<<endl;
	}
};
class Derived:public Base2
{
 public:
	 void display()const
	 {
		 cout << "Derived::display()"<<endl;
	 }
};

void fun(Base1 *ptr)
{
	ptr->display();
}

int main()
{
	Base1 base1;
	Base2 base2;
	Derived derived;
	fun(&base1);
	fun(&base2);
	fun(&derived);
	return 0;
}

输出：

Base1::display()
Base1::display()
Base1::display()

为什么会有这样的结果呢？ 因为我们是用一个base1类的指针调用函数fun()，虽然实际上这个指针指向的是base2类的对象，但编译器无法知道这一事实（直到运行的时候，程序才可以根据用户的输入判断出指针指向的对象），它只能按照调用Parent类的函数来理解并编译，所以我们看到了第二行的结果。

添加virtual关键字后

#include <iostream>
using namespace std;

class Base1
{
 public:
	 virtual void display()const               //添加virtual关键字
	 {
		 cout<<"Base1::display()"<<endl;
	 }
};
class Base2 : public Base1
{	
 public:
	 void display()const
	{
		cout<<"Base2::display()"<<endl;
	}
};
class Derived:public Base2
{
 public:
	 void display()const
	 {
		 cout << "Derived::display()"<<endl;
	 }
};

void fun(Base1 *ptr)
{
	ptr->display();
}

int main()
{
	Base1 base1;
	Base2 base2;
	Derived derived;
	fun(&base1);
	fun(&base2);
	fun(&derived);
	return 0;
}

输出：

Base1::display()
Base2::display()
Derived::display()

那么现在结果又是怎么回事呢？我们注意到，display()函数在基类中被virtual关键字修饰，也就是说，它是一个虚函数。 虚函数最关键的特点是“动态联编”，它可以在运行时判断指针指向的对象，并自动调用相应的函数。 

 

 ________________________________________分        隔        符______________________________________________

 

当没有用virtual关键字时（如f1()），重写了基类的函数（函数名相同，参数相同），基类的函数被隐藏（注意别与覆盖混淆）。
当有virtual关键字时（f2（）），基类的f2（）被覆盖了，而不是隐藏了。                                           

   ——直接类调用

#include <iostream>
using namespace std;
class A
{
public:
    void f1()                               //添加virtual
    {
        cout << "A---f1" << endl;
    }
    void f2()                               //添加virtual
    {
        cout << "A---f2" << endl;
    }
};
class B:A
{
public:
    void f1()
    {
        cout << "B---f1" << endl;
    }
 
     void f2()
    {
        cout << "B---f2" << endl;
    }
};
void main()
{
    A a;
    B b;
    a.f1();
    a.f2();
    b.f1();
    b.f2();
    system("pause");
}

 无论是否添加virtual，输出结果相同：

A---f1
A---f2
B---f1
B---f2

重载与覆盖的区别：
成员函数被重载的特征：
（1）相同的范围（在同一个类中）；
（2）函数名字相同；
（3）参数不同；
（4）virtual 关键字可有可无。
覆盖是指派生类函数覆盖基类函数，特征是：
（1）不同的范围（分别位于派生类与基类）；
（2）函数名字相同；
（3）参数相同；
（4）基类函数必须有virtual 关键字。
“隐藏”是指派生类的函数屏蔽了与其同名的基类函数
（1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual 关
键字，基类的函数将被隐藏（注意别与重载混淆）。
（2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual
关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）。有virtual关键字，则基类的函数被覆盖。