第十三章 虚函数

第十三章 虚函数

1.  指向对象的指针

常用father *pfather=new son;

不常用son *pson=new son;？？？？？？？？？

2.  虚函数

覆盖 体现虚函数的多态性(动态联编)

基类指针存储不同对象调用不同类的函数

5.  在编译时的静态联编

6.  在运行时的静态联编

7.  在运行时的动态联编（耗时）

动态联编体现了多态性 所以一定要有virtual 而且要用指针或者别名 否则不能实现

8.  在编译时的动态联编

9.  三种调用虚函数的方式比较

要想显示virtual

①存储不同对象的指针调用不同类的函数

②声明: 调用:  第一个按对象传递调用 不能呈现多态性。 按指针或引用传递 能呈现多态性

10.  系统是如何调用虚函数的

11.  在虚函数中使用成员名限定 

在虚函数中使用成员名限定可以强行解除动态联编

12.  构造函数和虚析构函数

如果基类中定义了虚函数，那么也要有虚析构函数。这样对内存的回收就会更准确些（一般都在基类加virtual）

没有虚构造函数

13.  纯虚函数

纯虚函数就是基类只定义了函数体，没有实现过程，定义方法如： virtual void Eat() = 0; 不要 在cpp中定义；纯虚函数相当于接口，不能直接实例化，需要派生类来实现函数定义；

带纯虚函数的类叫虚基类，这种基类不能直接生成对象，而只有被继承，并重写其虚函数后，才能使用。这样的类也叫抽象类。 

虚函数是为了继承接口和默认行为

纯虚函数只是继承接口，行为必须重新定义

本章总结：

1.  动态联编（速度慢）（运行后才能确定指针指向那个对象）            静态联编（速度快）（编译后就能确定指针指向那个对象）

2.  只有基类virtual、父类指针、不同new类          的连用才能体现多态性

3.  成员名限定符可以强制解除动态联编p->Fahter::get();

4.  有虚函数，就要有虚析构函数(注意：只要看到派生类，不论有无虚函数，都要有虚析构函数)

5.  虚函数、虚析构函数virtual都设在基类

/**
运行时的动态联编
动态联编体现了多态性，一定要用virtual和指针，才能展示*******************①
*/

    
//#include"iostream"
//using namespace std;
//class Father
//{
//public:
//    Father(){cout<<"Father";}
//    virtual int get(){return 1;}
//
//};
//class Son:public Father
//{
//public:
//    Son(){cout<<"Son";}
//    int get(){return 2;}
//};
//int main()
//{
//    while(1)
//    {
//        bool x=false;
//        Father *P;
//        bool quit=false;
//        do
//        {            
//            x=false;
//            cout<<"（1）父类（2）子类（3）退出：";
//            int choice;
//            cin>>choice;
//            
//            switch(choice)
//            {
//            case 1:P=new Father;
//                  break;
//            case 2:P=new Son;
//                  break;
//            case 3:quit=true;
//                  break;
//            default:cout<<"请输入进行选择:
";x=true;
//                  break;
//            }
//        }while(x==true);
//            
//        if(quit==true)//如果误写成quit=true那就直接运行了
//        {
//            break;
//        }
//        else 
//        {
//            cout<<P->get()<<endl;
//            delete P;
//            P=NULL;        
//        }
//        
//    }
//
//    return 0;
//}




//#include"iostream"
//using namespace std;
//class A
//{
//public:
//    virtual void one(){cout<<"one"<<endl;two();};
//    //此处一个virtual就可以了，因为以后的函数都有one间接调用************************②
//    void two(){cout<<"two"<<endl;three();}
//    void three(){cout<<"three"<<endl;four();}
//    void four(){cout<<"three"<<endl;five();}
//    void five(){cout<<"three"<<endl;}    
//};
//class B:public A
//{
//public:
//    void one(){cout<<"1"<<endl;two();};
//    void two(){cout<<"2"<<endl;three();}
//    void three(){cout<<"3"<<endl;four();}
//    void four(){cout<<"4"<<endl;five();}
//    void five(){cout<<"5"<<endl;}
//};
//class C:public A
//{
//public:
//    void one(){cout<<"一"<<endl;two();};
//    void two(){cout<<"二"<<endl;three();}
//    void three(){cout<<"三"<<endl;four();}
//    void four(){cout<<"四"<<endl;five();}
//    void five(){cout<<"五"<<endl;}
//};
//int main()
//{
//    A *p;
//    int choice;
//    bool quit=false;
//    int x;
//    while(1)
//    {
//        do
//        {
//            x=0;
//            cout<<"（0）退出（1）英文（2）阿拉伯文（3）中文"<<endl;
//            cin>>choice;
//            switch(choice)
//            {
//            case 0:cout<<"退出程序"<<endl;quit=true;
//                break;
//            case 1:cout<<"英文："<<endl;p=new A;
//                break;
//            case 2:cout<<"阿拉伯文："<<endl;p=new B;
//                break;
//            case 3:cout<<"中文："<<endl;p=new C;
//                break;
//            default:cout<<"请做出正确选择："<<endl;x=1;
//            }
//        }while(x==1);
//        if(quit)
//            break;
//        else
//        {
//            p->one();
//            //p->A::one();//成员限定符能强制解除动态联编
//            delete p;
//            p=NULL;
//        }
//    }
//    return 0;
//}




//有virtual函数就要有virtual析构函数
#include"iostream"
using namespace std;
class A
{
public:
    A(){cout<<"A类的构造函数"<<endl;}//构造函数没有虚函数****************③
    void fun(){cout<<"类A的fun()函数"<<endl;}
    virtual ~A(){cout<<"A类的析构函数"<<endl<<endl;}
};
class B:public A
{
public:
    B(){cout<<"B类的构造函数"<<endl;}
    void fun(){cout<<"类B的fun()函数"<<endl;}
    ~B(){cout<<"B类的析构函数"<<endl;}
};
int main()
{
    A *pa=new A;
    pa->fun();
    delete pa;
    pa=NULL;

    A *pb=new B;//用指向B类的A类指针调用重载函数，基类的析构函数要设为虚函数*********************④
    pb->fun();
    delete pb;
    pb=NULL;
    return 0;
}