c++继承2虚函数

这篇文章谈谈c++中的虚函数，在我看来如果是单纯的通过对象来访问的话，虚函数和一般的函数是没有什么区别的，当然这里没有包括纯虚函数，如果我们只通过对象来访问的话，那么这也就缺少了c++的动态特性了，当我们通过指针或者引用来访问的时候，我们可以发现，我们可以发现，我们会去找派生类中的函数，我想这也是为什么java中写的方法总是会覆盖父类的方法。代码中我对引用和指针都做了例子：

代码：

//这段代码是简单的virtual的例子，如果函数是通过对象来直接访问的话，那么声明为虚函数和不是虚函数是没有太大区别的，
//如果我们通过引用或指针来访问，那么我们的虚函数会首先找到派生类中的函数，或者这也是java中子类的总会覆盖父类的方法的原因吧。 
#include<iostream>
using namespace std;
class Person{
    private :
        string name;
        int age;
    public :
        //构造函数 
        Person(string str_name,int int_age){
            name=str_name;
            age=int_age;
            }
            //显示函数 
        void show(){
            cout<<"DPerson"<<name<<":"<<age<<endl;
        }
        //虚显示函数 
        virtual void display(){
            cout<<"DPerson"<<name<<":"<<age<<endl;
        }
        //返回名字 
        string getName(){
            return name;
        }
        //返回年龄 
        int getAge(){
            return age;}
        
    };
class Student:public Person{
    private :
        string number;
    public :
        //构造函数 
        Student(string str_name,int int_age,string str_number):Person(str_name,int_age){
            number=str_number;
        }
        //派生类显示函数 
        void show(){
            cout<<"SStudent"<<getName()<<":"<<getAge()<<":"<<number<<endl;
            }
            //虚函数具体实现 
        void display(){
            cout<<"DStudent"<<getName()<<":"<<getAge()<<":"<<number<<endl;}
            
    };
 int main(){
    Person p("jike",12);
    Student stu("jike",123,"120520");
    //调用Person.show() 
    p.show();
    //调用Person.display() 
    p.display();
    //调用Student.show() 
    stu.show();
    //调用Student.display() 
    stu.display();
    Person &p_ref=p;
    Person &stu_ref=stu;
    //调用Person.show() 
    p_ref.show();
    //调用Person.display() 
    p_ref.display();
    //调用Person.show() 
    stu_ref.show();
    //调用Student.display() 
    stu_ref.display();
    //这里使用指针和使用引用的调用是相同的 
    Person * p_point;
    p_point=&p;
    Person * stu_point;
    stu_point=&stu;
    p_point->show();
    p_point->display();
    stu_point->show();
    stu_point->display(); 
    system("pause");
    } 

在文章的后面，我也写了一个将基类的析构函数定义成为虚函数的例子，并写出了析构函数的执行的顺序。

//这段代码演示的析构函数设置为虚函数，然后析构函数的执行顺序，我们只需要将基类的析构函数定义成为虚函数，无论以后派生出来多少都是按照最后一个派生依次向上。 
#include<iostream>
using namespace std;
class Person{
    private:
    int age;
    public:
        Person(){
            }
    Person(int age){
        age=age;
    }
    //将析构函数定义成为虚函数 
    virtual ~Person(){
        cout<<"Person"<<endl;
    }
};
class Student:public Person{
    public :
        //中间类的析构函数 
         ~Student(){
            cout<<"Student"<<endl;
        }
};
class GoodStudent:public Student{
    public:
        //最后一个类的析构函数 
        ~GoodStudent(){
            cout<<"GoodStudent"<<endl;
        }
} ;
int main(){ 
    Person *p;
    p=new GoodStudent;
    delete p;
    //执行顺序GoodStudent,Student,Person 
    system("pause");
    return 0;
}