初识C++之虚函数

1、什么是虚函数
  在基类中用virtual关键字修饰,并在一个或多个派生类中被重新定义的成员函数,用法格式为:
  virtual 函数返回类型 函数名(参数表)
   {
    函数体
   }
   虚函数是实现多态性的关键,通过指向派生类的基类指针或引用,访问派生类中同名覆盖成员函数。
  
看两个例子:
①没有定义基类的Fun函数为虚函数:

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;

class Base
{
public:
    void Fun()
    {
        cout << "Base::Fun()" << endl;
    }
private:
    int data;
};

class Derived : public Base
{
public:
    void Fun()
    {
        cout << "Derived::Fun()" << endl;
    }
private:
    int data;
};

int main()
{
    Derived d;
    Base* pb = &d;
    pb->Fun();
    return 0;
}

这里写图片描述
可以看到此时基类指针虽然指向的是派生类,但仍然调用的是基类的Fun函数。

②定义了基类的Fun函数为虚函数:

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;

class Base
{
public:
    virtual void Fun()     //注意这儿加了关键字virtual
    {
        cout << "Base::Fun()" << endl;
    }
private:
    int data;
};

class Derived : public Base
{
public:
    void Fun()
    {
        cout << "Derived::Fun()" << endl;
    }
private:
    int data;
};

int main()
{
    Derived d;
    Base* pb = &d;
    pb->Fun();
    return 0;
}

这里写图片描述
可以看到此时基类指针指向派生类后,其调用Fun函数时就是调用派生类的Fun函数了,从这儿也能看出虚函数是实现多态的关键。

2、虚函数的实现
①在基类中用virtual关键字修饰成员函数,使之成为一个虚函数,在派生类中重写该函数,使之完成新的功能。

②派生类中重写该虚函数时,要求重写的函数的函数名、参数列表、返回值都与基类虚函数相同,函数体根据需要选择是否重写。若不重写,则直接完成继承于基类。
PS:C++规定,当一个成员函数被定义为虚函数时,其派生类中的同名函数都自动变为虚函数,因此,派生类在重新定义该虚函数时,可加virtual关键字,也可以不加,但为了层次的清晰与代码的易读性,最好还是加上(那感觉前面说的都是废话)。

③定义一个基类的指针,使之指向同一类族中需要调用的函数所在类的对象。
PS:基类与派生类的赋值关系可以参考下面这篇博客中的第六条:
http://blog.csdn.net/ljx_5489464/article/details/51114534

④通过该指针调用虚函数,此时调用的就是指针指向的对象的同名函数了。

用一个实例来说明上述实现机制:

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;

class Base
{
public:
    virtual void Fun()     //加virtual关键字
    {
        cout << "Base::Fun()" << endl;
    }
private:
    int data;
};

class Derived : public Base
{
public:
    void Fun()
    {
        //重写Fun函数的函数体,当然,这儿不是必须要重写的
        cout << "Derived::Fun()" << endl;
    }
private:
    int data;
};

class Derived_Derived : public Derived
{
public:
    void Fun()
    {
        //重写Fun函数的函数体,当然,这儿不是必须要重写的
        cout << "Derived_Derived::Fun()" << endl;
    }
private:
    int data;
};

int main()
{
    Derived_Derived d;
    Derived* pb = &d;
    pb->Fun();
    return 0;
}

这里写图片描述
我在Derived类中并没有在Fun函数前加virtual关键字,但pb指针调用的却是Derived_Derived类中的Fun函数,而非Derived类中的,这就说明了只要基类的成员函数被定义为虚函数时,派生类的同名函数就会变为虚函数。

注意:虚函数只能出现在类的继承层次中,只能定义类的成员函数为虚函数,不能定义类外的普通函数为虚函数:

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;

virtual void Fun()     //注意这儿加了关键字virtual
{
    cout << "Base::Fun()" << endl;
}

int main()
{
    Fun();
    return 0;
}

以上代码会报错:
这里写图片描述

3、虚析构函数
  析构函数执行时先调用派生类的析构函数,其次才调用基类的析构函数。如果析构函数不是虚函数,而程序执行时又要通过基类的指针去销毁派生类的动态对象(用new运算符创建的),那么用delete销毁对象时,只调用了基类的析构函数,未调用派生类的析构函数。这样会造成销毁对象不完全。

看例子:

#define _CRT_SECURE_NO_WARNINGS 1 
#include <iostream> 
using namespace std; 

class Base 
{ 
public: 
  Base()
  { 
    cout << "Base()" << endl; 
  }
  
  ~Base() 
  {
    cout << "~Base()" << endl; 
  } 
private: 
  int data; 
};

class Derived: public Base 
{
public: 
  Derived()
  {
    cout << "Derived()" << endl;
  }
  
  ~Derived()
  {
    cout << "~Derived()" << endl;
  }
private: 
  int data;
}; 

int main()
{ 
  Base *pb = new Derived;
  delete pb; 
  return 0; 
}

这里写图片描述
可以看到,确实是只调用了基类的析构函数,派生类的析构函数并没有被调用。

当我把基类的析构函数改成这样:

virtual ~Base() 
{
  cout << "~Base()" << endl;
} 

再运行时,结果如下:
这里写图片描述

可以看到,此时不管是基类还是派生类的的析构函数都被调用了,为什么呢?
解析如下:
假设Derive类public继承自Base类,并且基类的析构函数没有定义为虚函数,有如下调用:
Base* pb = new Derive;
delete pb;
这时候,delete pb时,编译器会把pb当成Base的一个对象看待,因为pb是Base类型的,所以直接去调用基类的析构函数;
若将基类的析构函数写成virtual函数,那么基类和派生类的析构函数会分别存放在自己的虚表中,这时再执行delete pb时,会调用析构函数,但现在虚构函数是虚函数,所以会到虚表中去查找,而此时pb指向的刚好是一个派生类对象,所以通过虚表查找就找到了派生类的虚函数,从而调用派生类的析构函数。

4、纯虚函数
①定义:
  纯虚函数是在基类中声明的虚函数,它在基类中没有定义,即没有函数体,但要求任何派生类都要实现自己的函数体。在基类中实现纯虚函数的方法是在函数原型后加“=0;“。
virtual void funtion()=0 ;

②引入原因 :
  为了方便使用多态特性,我们常常需要在基类中定义虚拟函数。 但在很多情况下,基类本身生成对象是不合情理的。例如,动物作为一个基类可以派生出老虎、孔雀等子类,但动物本身生成对象明显不合常理。 为了解决上述问题,引入了纯虚函数的概念,将函数定义为纯虚函数,则编译器要求在派生类中必须予以重写以实现多态性。这样就很好地解决了上述两个问题。

③作用:
  纯虚函数的作用是在基类中为其派生类保留一个函数的名字,以便派生类根据需要对其进行实现,从而实现多态性。

④抽象类
  不用来定义对象,只是作为一种基本类型用作继承的类,称为抽象类,由于抽象类通常作为基类,所以也称为抽象基类。包含纯虚函数的类就是抽象类,它不能生成对象。

注意:
①纯虚函数没有函数体;
②纯虚函数声明形式最后的“=0;”并不是返回值是0,它只是起一个形式上的作用,告诉编译器这是虚函数;
③虚函数的声明形式是一个语句,最后要加上“;”。
④纯虚函数只有声明,没有函数体,所以它不具有函数功能,因此不能被调用,可以称其为“徒有其表”。
⑤如果一个类中声明了虚函数,且在其派生类中没有被实现,那么在派生类中它仍为纯虚函数。

最后用一个实例来剖析:

class Animal
{
public:
    virtual void Sleep() = 0;   //这里声明Sleep为纯虚函数
public:
    char sex[5];
    int age;
};

class Person: public Animal
{
public:
    virtual void Sleep()
    {
        cout << "Person lying down to sleep!" << endl;
    }
public:
    char notionality[20];   //国籍
    char name[10];
};

class Horse: public Animal
{
public:
    virtual void Sleep()
    {
        cout << "Horse sleep standing up!" << endl;
    }
public:
    char rase[20];          //种族
};

int main()
{
    Animal a;
    return 0;
}

这里写图片描述
此时用含有纯虚函数Sleep的抽象类Animal来创建对象时,会报错。

我把主函数改为调用抽象类Animal中的Sleep函数:

int main()
{
    Animal::Sleep();
    return 0;
}

这里写图片描述
调用一个纯虚函数,会报错。

我把Person修改了,去掉它对Sleep函数的实现:

class Person: public Animal
{
public:
    char notionality[20];   //国籍
    char name[10];
};

这里写图片描述
此时Person类中没有对Sleep函数进行实现,因此,Person类中的Sleep函数仍为虚函数,会报错。

评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值