详解C++中的纯虚函数（虚函数区别）&多态性以及实例应用

在C++中的一种函数申明被称之为：纯虚函数(pure virtual function).它的申明格式如下：

class CShape

{

public:

    virtual void Show() =0;

};

 

类的一个成员定位虚函数的实际意义在于让C++知道该函数并无意义，它的作用只是为了让派生类进行函数重载保留位置。

注意红色部分，在普通的虚函数后面加上"=0"这样就声明了一个pure virtual function.

 

废话不说先看例子：

 1 #include <iostream>

 2 #include <cstdlib>

 3 #include <cstdio>

 4 

 5 using namespace std;

 6 

 7 

 8 class abstractcls

 9 {

10 public:

11     abstractcls(float speed,int total)   //构造函数

12     {

13         this->speed = speed;

14         this->total = total;

15     }

16 

17     virtual void showmember()= 0;    //纯虚函数的定义

18 protected:

19     float speed;

20     int total;

21 };

22 

23 class car : public abstractcls

24 {

25 public:

26     car(int aird,float speed,int total):abstractcls(speed,total)

27     {

28         this->aird = aird;

29     }

30 

31     virtual void showmember()

32     {

33         cout << speed <<"--------" <<total <<"-----------"<<aird<<endl;

34     }

35 protected:

36     int aird;

37 };

38 int main()

39 {

40     car b(250,150,4);

41     b.showmember();

42     return 0;

43 }

运行结果想必大家都知道！！就不写了！！

总结：什么时候需要用纯虚函数

1,当想要在基类中抽象出一个方法，且该类被继承类而不能被实例化时。
2,基类的方法必须在派生类中被实现时。
3,多个对象具有公共的抽象属性，但却有不同的实现要求时。

下面我们看一道某公司的面试的笔试题（含金量到底有多少？？）

#include <iostream>

#include <cstdio>



using namespace std;



class A

{

public:

    void foo()

    {

        printf("1\n");

    }

    virtual void fuu()

    {

        printf("2\n");    

    }

};



class B:public A

{

public :

    void foo()

    {

        printf("3\n");

    }

    void fuu()

    {

        printf("4\n");

    }

};



int main()

{

    A a;

    B b;

    

    A *p = &a;

    cout<< "p->foo()---" ; p->foo() ; 

    cout<<"p->fuu()---";p->fuu();    



    cout <<"-------向上转型-----------"<<endl;

    p=&b;

    cout<<"p->foo()---";p->foo();    

    cout<<"p->fuu()---";p->fuu();    

    

    cout <<"--------向下转型----------"<<endl;

    

    B *ptr =(B *)&a;

    cout<<"ptr->foo()----";ptr->foo();

    cout<<"ptr->fuu()-----";ptr->fuu();

    return 0;

}

先不要看答案，看自己能否作对？？

 

 

 

运行结果：

下面进行详细分析一下为什么结果是这样的？？你全做对了没？？

      第一个p->foo()和p->fuu()都很好理解，本身是基类指针，指向的又是基类对象，调用的都是基类本身的函数，因此输出结果就是1、2。
　　第二个输出结果就是1、4。p->foo()和p->fuu()则是基类指针指向子类对象，正式体现多态的用法，p->foo()由于指针是个基类指针，指向是一个固定偏移量的函数，因此此时指向的就只能是基类的foo()函数的代码了，因此输出的结果还是1。而p->fuu()指针是基类指针，指向的fuu是一个虚函数，由于每个虚函数都有一个虚函数列表，此时p调用fuu()并不是直接调用函数，而是通过虚函数列表找到相应的函数的地址，因此根据指向的对象不同，函数地址也将不同，这里将找到对应的子类的fuu()函数的地址，因此输出的结果也会是子类的结果4.

 

　　第三个并不是很理解这种用法，从原理上来解释，由于B是子类指针，虽然被赋予了基类对象地址，但是ptr->foo()在调用的时候，由于地址偏移量固定，偏移量是子类对象的偏移量，于是即使在指向了一个基类对象的情况下，还是调用到了子类的函数，虽然可能从始到终都没有子类对象的实例化出现。

　　第四个：而ptr->fuu()的调用，可能还是因为C++多态性的原因，由于指向的是一个基类对象，通过虚函数列表的引用，找到了基类中foo()函数的地址，因此调用了基类的函数。由此可见多态性的强大，可以适应各种变化，不论指针是基类的还是子类的，都能找到正确的实现方法。

 

小结：1.有virtual才可能发生多态现象2.不发生多态（无virtual）调用就按原类型调用

 

#include <iostream>



using namespace std;



class Base

{

public:

    virtual void f(float x)

    {

        cout <<"Base::f(float)"<<x <<endl;

    }

    void g(float x)

    {

        cout <<"Base::g(float)"<<x<<endl;

    }

    void h(float x)

    {

        cout <<"Base::h(float)"<<x<<endl;

    }

};



class Derived:public Base

{

public:

    virtual void f(float x)

    {

        cout <<"Derived::f(float)"<<x<<endl;

    }



    void g(int x)

    {

        cout <<"Derived::g(int)"<<x <<endl;

    }



    void h(float x)

    {

        cout << "Derived::h(float)"<<x <<endl;

    }

};



int main()

{

    Derived d;

    Base *pb = &d;

    Derived *pd = &d;



    pb->f(3.14f);   

    pd->f(3.14f);    



    pb->g(3.14f);    

    pd->g(3.14f);   



    pb->h(3.14f);    

    pd->h(3.14f);    

    system("pause");



}

 

 

运行结果：

虚函数和纯虚函数

在面向对象的C++语言中，虚函数（virtual function）是一个非常重要的概念。因为它充分体现了面向对象思想中的继承和多态性这两大特性，在C++语言里应用极广。比如在微软的MFC类库中，你会发现很多函数都有virtual关键字，也就是说，它们都是虚函数。难怪有人甚至称虚函数是C++语言的精髓。

那么，什么是虚函数呢，我们先来看看微软的解释：

虚函数是指一个类中你希望重载的成员函数，当你用一个基类指针或引用指向一个继承类对象的时候，你调用一个虚函数，实际调用的是继承类的版本。

——摘自MSDN

这个定义说得不是很明白。MSDN中还给出了一个例子，但是它的例子也并不能很好的说明问题。我们自己编写这样一个例子：

 

#include <iostream>

#include <conio.h>

using namespace std;



class Parent

{

public:

    char data[20];

    void Function1();

    virtual void Function2();

}parent;



void Parent::Function1()

{

    printf("This is parent,function1\n");

}



void Parent::Function2()

{

    printf("This is parent,function2\n");

}



class Child:public Parent

{

    void Function1();

    void Function2();

}child;



void Child::Function1()

{

    printf("This is child,function1\n");

}



void Child::Function2()

{

    printf("This is child,function2\n");    

}





int main()

{

    Parent *p;

    if(_getch()=='c')

        p =&child;

    else

        p=&parent;



    p->Function1();

    

    p->Function2();



    return 0 ;



    

}

输入非c字符：运行结果：

 

输入c字符：运行结果：

 

在这里就不过多解释以上程序，紧接着讲一下C++中虚函数和纯虚函数的虚别

首先：强调一个概念
定义一个函数为虚函数，不代表函数为不被实现的函数
定义他为虚函数是为了允许用基类的指针来调用子类的这个函数

定义一个函数为纯虚函数，才代表函数没有被实现
定义他是为了实现一个接口，起到一个规范的作用，规范继承这个
类的程序员必须实现这个函数。

对继承的影响：
普通的类（没有虚函数，纯虚函数）就可以被继承，而且工作的相当好

关于这个问题有以下疑问：
纯虚函数难道就是为了实现接口？接口存在的意义？
我实在弄不懂，我干嘛要预先定义好？未来的事情本难料
就等有一天我的类中需要使用某个函数，在添加一个函数