首页 > 代码库 > 第十三章 虚函数

第十三章 虚函数

2024-07-04 23:07:56   230人阅读

第十三章 虚函数

1.  指向对象的指针

常用

不常用？？？？？？？？？

2.  虚函数

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

 

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

3.  拳击游戏

 

 

4.  继承是否可以实现多态性

继承无法实现多态,要想实现多态就要在基类加virtual

5.  在编译时的静态联编

6.  在运行时的静态联编

7.  在运行时的动态联编

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

8.  在编译时的动态联编

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

要想显示virtual

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

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

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

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

  

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

 

本章总结：

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

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

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

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

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

  1 /**
  2 运行时的动态联编
  3 动态联编体现了多态性，一定要用virtual和指针，才能展示*******************①
  4 */
  5 
  6     
  7 //#include"iostream"
  8 //using namespace std;
  9 //class Father
 10 //{
 11 //public:
 12 //    Father(){cout<<"Father";}
 13 //    virtual int get(){return 1;}
 14 //
 15 //};
 16 //class Son:public Father
 17 //{
 18 //public:
 19 //    Son(){cout<<"Son";}
 20 //    int get(){return 2;}
 21 //};
 22 //int main()
 23 //{
 24 //    while(1)
 25 //    {
 26 //        bool x=false;
 27 //        Father *P;
 28 //        bool quit=false;
 29 //        do
 30 //        {            
 31 //            x=false;
 32 //            cout<<"（1）父类（2）子类（3）退出：";
 33 //            int choice;
 34 //            cin>>choice;
 35 //            
 36 //            switch(choice)
 37 //            {
 38 //            case 1:P=new Father;
 39 //                  break;
 40 //            case 2:P=new Son;
 41 //                  break;
 42 //            case 3:quit=true;
 43 //                  break;
 44 //            default:cout<<"请输入进行选择:\n";x=true;
 45 //                  break;
 46 //            }
 47 //        }while(x==true);
 48 //            
 49 //        if(quit==true)//如果误写成quit=true那就直接运行了
 50 //        {
 51 //            break;
 52 //        }
 53 //        else 
 54 //        {
 55 //            cout<<P->get()<<endl;
 56 //            delete P;
 57 //            P=NULL;        
 58 //        }
 59 //        
 60 //    }
 61 //
 62 //    return 0;
 63 //}
 64 
 65 
 66 
 67 
 68 //#include"iostream"
 69 //using namespace std;
 70 //class A
 71 //{
 72 //public:
 73 //    virtual void one(){cout<<"one"<<endl;two();};
 74 //    //此处一个virtual就可以了，因为以后的函数都有one间接调用************************②
 75 //    void two(){cout<<"two"<<endl;three();}
 76 //    void three(){cout<<"three"<<endl;four();}
 77 //    void four(){cout<<"three"<<endl;five();}
 78 //    void five(){cout<<"three"<<endl;}    
 79 //};
 80 //class B:public A
 81 //{
 82 //public:
 83 //    void one(){cout<<"1"<<endl;two();};
 84 //    void two(){cout<<"2"<<endl;three();}
 85 //    void three(){cout<<"3"<<endl;four();}
 86 //    void four(){cout<<"4"<<endl;five();}
 87 //    void five(){cout<<"5"<<endl;}
 88 //};
 89 //class C:public A
 90 //{
 91 //public:
 92 //    void one(){cout<<"一"<<endl;two();};
 93 //    void two(){cout<<"二"<<endl;three();}
 94 //    void three(){cout<<"三"<<endl;four();}
 95 //    void four(){cout<<"四"<<endl;five();}
 96 //    void five(){cout<<"五"<<endl;}
 97 //};
 98 //int main()
 99 //{
100 //    A *p;
101 //    int choice;
102 //    bool quit=false;
103 //    int x;
104 //    while(1)
105 //    {
106 //        do
107 //        {
108 //            x=0;
109 //            cout<<"（0）退出（1）英文（2）阿拉伯文（3）中文"<<endl;
110 //            cin>>choice;
111 //            switch(choice)
112 //            {
113 //            case 0:cout<<"退出程序"<<endl;quit=true;
114 //                break;
115 //            case 1:cout<<"英文："<<endl;p=new A;
116 //                break;
117 //            case 2:cout<<"阿拉伯文："<<endl;p=new B;
118 //                break;
119 //            case 3:cout<<"中文："<<endl;p=new C;
120 //                break;
121 //            default:cout<<"请做出正确选择："<<endl;x=1;
122 //            }
123 //        }while(x==1);
124 //        if(quit)
125 //            break;
126 //        else
127 //        {
128 //            p->one();
129 //            //p->A::one();//成员限定符能强制解除动态联编
130 //            delete p;
131 //            p=NULL;
132 //        }
133 //    }
134 //    return 0;
135 //}
136 
137 
138 
139 
140 //有virtual函数就要有virtual析构函数
141 #include"iostream"
142 using namespace std;
143 class A
144 {
145 public:
146     A(){cout<<"A类的构造函数"<<endl;}//构造函数没有虚函数****************③
147     void fun(){cout<<"类A的fun()函数"<<endl;}
148     virtual ~A(){cout<<"A类的析构函数"<<endl<<endl;}
149 };
150 class B:public A
151 {
152 public:
153     B(){cout<<"B类的构造函数"<<endl;}
154     void fun(){cout<<"类B的fun()函数"<<endl;}
155     ~B(){cout<<"B类的析构函数"<<endl;}
156 };
157 int main()
158 {
159     A *pa=new A;
160     pa->fun();
161     delete pa;
162     pa=NULL;
163 
164     A *pb=new B;//用指向B类的A类指针调用重载函数，基类的析构函数要设为虚函数*********************④
165     pb->fun();
166     delete pb;
167     pb=NULL;
168     return 0;
169 }

 

 


联系
我们