C++:虚函数的详解

  1. 云栖社区>
  2. 博客>
  3. 正文

C++:虚函数的详解

吞吞吐吐的 2017-09-12 15:23:00 浏览578
展开阅读全文

5.4.2 虚函数详解


1.虚函数的定义
虚函数就是在基类中被关键字virtual说明,并在派生类重新定义的函数。虚函数的作用是允许在派生类中重新定义与基类同名的函数,并且可以通过基类指针或引用来访问基类和派生类中的同名函数。

虚函数的定义是在基类中进行的,它是在基类中需要定义为虚函数的成员函数的声明中冠以关键字virtual。定义虚函数的格式如下:

virtual 函数类型 函数名(形参表)
{
     函数体 
}
在基类中的某个成员函数声明为虚函数后,此虚函数就可以在一个或多个派生类中被重新定义。在派生类中重新定义时,其函数类型、函数名、参数个数、参数类型的顺序,都必须与基类中的原型完全相同。 

//例 5.21 虚函数的使用

复制代码
#include<iostream>
using namespace std;
class B0{
 public:
   virtual void print(char *p)      //定义基类B0中的虚函数 
   {
     cout<<p<<"print()"<<endl;
   }
};
class B1:public B0{
  public:

    virtual void print(char *p)     //定义基类B0的公有派生类B1中的虚函数
    {
     cout<<p<<"print()"<<endl;
    }
};
class B2:public B1{
  public:
    virtual void print(char *p)     //定义基类B1的公有派生类B2中的虚函数
    {
     cout<<p<<"print()"<<endl;
    }
};
int main()
{
 B0 ob0,*op;                  //定义基类对象ob0和对象指针op 
 op=&ob0;op->print("B0::");   //调用基类的B0的print()
 B1 ob1;                      //定义派生类B1的对象ob1 
 op=&ob1;op->print("B1::");   //调用派生类B1的print() 
 B2 ob2;                      //定义派生类B2的对象ob2
 op=&ob2;op->print("B2::");   //调用派生类B2的print()
 return 0;
} 
 /*
   在程序中,语句op->print();
   出现了3次,由于op指向的对象不同,每次出现都执行了相应对象的虚函数print
   
   程序运行结果:
     B0::print()
     B1::print()
     B2::print()
复制代码

说明:
(1)若在基类中,只是声明虚函数原型(需要加上virtual),而在类外定义虚函数时,则不必再加上virtual。

(2)在派生类中重新定义时,其函数类型、函数名、参数个数、参数类型的顺序,都必须与基类中的原型完全相同。

(3)C++规定,当一个成员函数被定义为虚函数后,其派生类中符合重新定义虚函数要求的同名函数都自动称为虚函数。因此,在派生类中重新定义该虚函数时,关键字virtual可写可不写。但是为了程序更加清晰,最好在每一层派生类中定义函数时都加上关键字virtual。

(4)如果在派生类中没有对基类的虚函数重新定义,则公有派生类继承其直接基类的虚函数。
一个虚函数无论被公有继承多少次。它仍然保持其虚函数的特性。
例如:
class B0{
      ...
      public:
              virtual void show(); //在基类中定义show为虚函数 
};
class B1:public B0{
      ...
};
若在公有派生类B1中没有重新定义虚函数show,则函数在派生类中被继承,仍然是虚函数。
(5)虚函数必须是其所在类的成员函数,而不能是友元函数,也不能是静态成员函数,因为虚函数的调用要靠特定的对象来决定该激活哪个函数。

(6)虽然使用对象名和点运算符的方式也可以调用虚函数,但是这种调用是在编译时进行的,是静态联编,它没有利用虚函数的特性。只有通过指针访问虚函数时才能获得运行时的多态性。

 

 2. 虚析构函数

在C++中,不能声明虚构造函数,但是可以声明虚析构函数。 
//例5.23 虚析构函数的引例

复制代码
#include<iostream>
using namespace std;
class B{
  public:
    ~B()
    {
     cout<<"调用基类B的析构函数\n";
    }
};
class D:public B{
  public:
    ~D()
    {
     cout<<"调用派生类D的析构函数\n";
    }
}; 
int main()
{
 D obj;
 return 0;
}
*/
/*
运行结果是: 
调用派生类D的析构函数
调用基类B的析构函数

显然本程序的运行结果是符和预想的。但是,如果在主函数中用new运算符建立一个无名对象
和定义了一个基类的对象指针,并将无名的对象的地址赋给这个对象指针。当用delete运算符
撤销无名对象时,系统只执行基类的析构函数,而不执行派生类的析构函数。
例如下面的例子: 
*/
复制代码

//例5.24 虚析构函数的引例2

复制代码
#include<iostream>
using namespace std;
class B{
  public:
    ~B()
    {
     cout<<"调用基类B的析构函数\n";
    }
};
class D:public B{
  public:
    ~D()
    {
     cout<<"调用派生类D的析构函数\n";
    }
}; 
int main()
{
 B *p;          //定义指向基类B的指针变量p 
 p = new D;     //用new运算符为派生类的无名对象动态的分配了一个存储空间,并将地址赋给对象指针p 
 delete p;      //用delete撤销无名对象时,释放动态存储空间 
 return 0;
} 
/* 程序运行结果: 调用基类B的析构函数 程序结果表示,本程序只执行了基类B的析构函数,而没有执行派生类D的析构函数。 原因是:当撤销指针p所指的派生类的无名对象,而调用析构函数时,采用了静态联编方式, 只调用了基类B的析构函数。 那么如何在撤销指针p所指的派生类的无名对象,既调用基类B的析构函数,也调用派生类D的 析构函数呢? 方法是:可以将基类的析构函数声明为虚析构函数,采用了多态性的动态联编方式。 虚析构函数没有类型,也没有参数,和普通虚函数相比,虚析构函数比较简单。 其声明格式:
virtual ~类名() */
复制代码

//例5.25 虚析构函数的使用

复制代码
#include<iostream>
using namespace std;
class B{
  public:
    virtual ~B()
    {
     cout<<"调用基类B的析构函数\n";
    }
};
class D:public B{
  public:
    ~D()
    {
     cout<<"调用派生类D的析构函数\n";
    }
}; 
int main()
{
 B *p;          //定义指向基类B的指针变量p 
 p = new D;     //用new运算符为派生类的无名对象动态的分配了一个存储空间,并将地址赋给对象指针p 
 delete p;      //用delete撤销无名对象时,释放动态存储空间 
 return 0;
}
/*
程序运行结果是:
调用派生类D的析构函数
调用基类B的析构函数

   说明:虽然派生类的析构函数与基类的析构函数名字不相同,但是如果将基类的析构函数
         定义为虚函数,则由该基类所派生的所有派生类的析构函数也都自动成为虚函数。 
*/ 
复制代码

3.虚函数与重载函数的关系
在一个派生类中重新定义基类的虚函数是函数重载的另一种形式,但它不同于一般函数重载。
当普通的函数重载时,其函数的参数或参数类型有所不同,函数的返回类型也可以不同。但是当重载一个虚函数时,也就是说在派生类中重新定义虚函数时,要求函数名、返回类型、参数个数、参数的类型和顺序与基类的虚函数原型完全相同。如果仅仅返回类型不同,其余均相同,系统会给出错误信息;若仅仅函数名相同,而参数的个数、类型或顺序不同,系统将它作为普通的函数重载,这时虚函数的特性将丢失。 

//例5.26 虚函数与重载函数的关系

复制代码
#include<iostream>
using namespace std;
class Base{
 public:
   virtual void func1();
   virtual void func2();
   virtual void func3();
   void func4();   
};
class Derived:public Base{
 public:
   virtual void func1();     //func1是虚函数,这里可以不写virtual 
   void func2(int i);        //与基类中的func2作为普通函数的重载,虚特性消失 
   //char func3();           //错误,因为与基类的func3返回类型不同,应删去 
   void func4();             //与基类中的func4是普通函数的重载,不是虚函数 
};
void Base::func1()
{
 cout<<"--Base func1--\n";
}
void Base::func2()
{
 cout<<"--Base func2--\n";
}
void Base::func3()
{
 cout<<"--Base func3--\n";
}
void Base::func4()
{
 cout<<"--Base func4--\n";
}
void Derived::func1()
{
 cout<<"--Derived func1--\n";
}
void Derived::func2(int i)
{
 cout<<"--Derived func2--\n";
}
void Derived::func4()
{
 cout<<"--Derived func4--\n";
}
int main()
{
 Base b,*pt;    //定义基类的对象b和对象指针pt 
 Derived d;     //定义派生类的对象d 
 pt = &d;       //基类的指针pt象派生类的对象d 
 pt->func1();   //调用的是派生类的fun1,结果是--Derived func1-- (虚函数的特性)
 pt->func2();   //调用的是基类的fun2,结果是--Base func2--(参数表中多了一个参数,变成普通重载函数,丢失虚函数的特性) 
 pt->func4();   //调用的是基类的fun4,结果是--Base func4--(基类和派生类中均没有virtual关键字,普通成员函数的重载) 
 return 0;
}
/*
程序运行结果是:
--Derived func1--
--Base func2--
--Base func4-- 
*/
复制代码

4. 多重继承与虚函数 

//例5.27 多重继承与虚函数的例子

复制代码
#include<iostream>
using namespace std;
class Base1{
  public:
   virtual void fun()           //定义fun是虚函数 
   {
    cout<<"--Base1--\n";
   }
}; 
class Base2{
  public: 
   void fun()                  //定义fun是普通的成员函数 
   {
    cout<<"--Base2--\n";
   }
};
class Derived:public Base1,public Base2{
  public:
   void fun()
   {
    cout<<"--Derived--\n";
   }
};
int main()
{
 Base1 *ptr1;
 Base2 *ptr2;
 Derived d;
 ptr1 = &d;  //基类的指针指向派生类的对象 
 ptr1->fun();/*(*ptr1).fun();*/  //调用派生类Derived的fun方法,因为它是由Base1派生来的,为虚函数,有虚特性 
 ptr2->fun();/*(*ptr2).fun();*/  //调用基类Base2的fun方法,派生类的fun方法是由Base2派生类来的,为普通成员重载函数 
 

 Derived obj;//基类的引用指向派生类的对象
 Base1 &p1 = obj;
 Base2 &p2 = obj;
 p1.fun();//调用派生类Derived的fun方法,因为它是由Base1派生来的,为虚函数,有虚特性 
 p2.fun();//调用基类Base2的fun方法,派生类的fun方法是由Base2派生类来的,为普通成员重载函数,无虚特性 
 
 return 0;
}
复制代码

5.虚函数的综合应用 

//例5.28 应用C++的多态性,计算三角形、矩形和圆的面积。

复制代码
#include<iostream>
#define PI 3.1416
using namespace std;
class Shape{                    //定义一个公共的基类 
   public:
   // Shape(){}
    Shape(double a=0.0,double b=0.0)  //带默认的构造函数 
    {
     x = a;
     y = b;
    }
    virtual void area()
    {
     cout<<"在基类中定义的虚基类";
     cout<<"为派生类提供一个公共的接口,";
     cout<<"以便派生类根据需要重新定义虚函数"<<endl;
    }
   protected:
    double x;
    double y;    
};
class Triangle:public Shape{     //定义一个三角形的派生类 
  public:
     Triangle(double a,double b):Shape(a,b){}
     void area()
     {
       cout<<"三角形的高是:"<<x<<","<<"底是:"<<y<<endl;    
       cout<<"三角形面积:"<<0.5*x*y<<endl;
     } 
};
class Square:public Shape{     //定义一个矩形的派生类 
  public:
     Square(double a,double b):Shape(a,b){}
     void area()
     {
       cout<<"矩形的长是:"<<x<<","<<"宽是:"<<y<<endl;        
       cout<<"矩形面积:"<<x*y<<endl;
     } 
}; 
class Circle:public Shape{     //定义一个圆的派生类 
  public:
     Circle(double a):Shape(a,a){}
     void area()
     {
       cout<<"圆的半径是:"<<x/2<<endl;    
       cout<<"圆面积:"<<PI*x*x<<endl;
     } 
}; 
int main()
{
 Shape *p,obj;                     //定义基类的对象指针p和对象obj 
 p=&obj;                           //基类的对象指针p指向基类的对象obj 
 p->area();                        //调用基类的area方法 
 Triangle t(10.0,6.0);             //定义三角形的对象t 
 Square s(10.0,6.0);               //定义矩形的对象s
 Circle c(10.0);                   //定义圆形的对象t
 p=&t;
 p->area();                        //计算三角形的面积 
 p=&s;
 p->area();                        //计算矩形的面积
 p=&c;
 p->area();                        //计算圆形的面积
 return 0;
} 
/*
 程序运行结果:
 在基类中定义的虚基类为派生类提供一个公共的接口,以便派生类根据需要重新定义虚函数
三角形的高是:10,底是:6
三角形面积:30
矩形的长是:10,宽是:6
矩形面积:60
圆的半径是:
圆面积:314.16 
*/
复制代码

 

程序猿神奇的手,每时每刻,这双手都在改变着世界的交互方式!
本文转自当天真遇到现实博客园博客,原文链接:http://www.cnblogs.com/XYQ-208910/p/4912639.html,如需转载请自行联系原作者

网友评论

登录后评论
0/500
评论
吞吞吐吐的
+ 关注