C++多态性，虚函数与纯虚函数

最新推荐文章于 2024-09-05 16:10:28 发布

bytxl

最新推荐文章于 2024-09-05 16:10:28 发布

阅读量1k

点赞数 2

分类专栏： C/C++

C/C++ 专栏收录该内容

160 篇文章 2 订阅

订阅专栏

http://blog.163.com/clevertanglei900@126/blog/static/111352259201011410822364/

http://blog.csdn.net/hackbuteer1/article/details/7475622

多态性：可以简单地概括为“一个接口，多种方法”，程序在运行时才决定调用的函数，它是面向对象编程领域的核心概念。多态(polymorphism)，字面意思多种形状。

虚函数：为了重载和多态的需要，在基类中是有定义的（即便定义是空）。所以子类中可以重写也可以不重写基类中的函数！

纯虚函数：在基类中是没有定义的，必须在子类中加以实现，很像java中的接口函数！

多态性

C++多态性是通过虚函数来实现的，虚函数允许子类重新定义成员函数，而子类重新定义父类的做法称为覆盖(override)，或者称为重写。（这里我觉得要补充，重写的话可以有两种，直接重写成员函数和重写虚函数，只有重写了虚函数的才能算作是体现了C++多态性）。

而重载则是允许有多个同名的函数，而这些函数的参数列表不同，允许参数个数不同，参数类型不同，或者两者都不同。编译器会根据这些函数的不同列表，将同名的函数的名称做修饰，从而生成一些不同名称的预处理函数，来实现同名函数调用时的重载问题。但这并没有体现多态性。
　　多态与非多态的实质区别就是函数地址是早绑定还是晚绑定。如果函数的调用，在编译器编译期间就可以确定函数的调用地址，并生产代码，是静态的，就是说地址是早绑定的。而如果函数调用的地址不能在编译器期间确定，需要在运行时才确定，这就属于晚绑定。

那么多态的作用是什么呢，封装可以使得代码模块化，继承可以扩展已存在的代码，他们的目的都是为了代码重用。而多态的目的则是为了接口重用。也就是说，不论传递过来的究竟是哪个类的对象，函数都能够通过同一个接口调用到适应各自对象的实现方法。

　　最常见的用法就是声明基类的指针，利用该指针指向任意一个子类对象，调用相应的虚函数，可以根据指向的子类的不同而实现不同的方法。如果没有使用虚函数的话，即没有利用C++多态性，则利用基类指针调用相应的函数的时候，将总被限制在基类函数本身，而无法调用到子类中被重写过的函数，即是隐藏。因为没有多态性，函数调用的地址将是一定的，而固定的地址将始终调用到同一个函数，这就无法实现一个接口，多种方法的目的了。

笔试题目：

#include<iostream>  
using namespace std;  
  
class A  
{  
public:  
    void foo()  
    {  
        printf("1\n");  
    }  
    virtual void fun()  
    {  
        printf("2\n");  
    }  
};  
class B : public A  
{  
public:  
    void foo()  
    {  
        printf("3\n");  
    }  
    void fun()  
    {  
        printf("4\n");  
    }  
};  
int main(void)  
{  
    A a;  
    B b;  
    A *p = &a;  
    p->foo();  
    p->fun();  
    p = &b;  
    p->foo();  
    p->fun();  
    return 0;  
}

第一个p->foo()和p->fun()都很好理解，本身是基类指针，指向的又是基类对象，调用的都是基类本身的函数，因此输出结果就是1、2。
　 第二个输出结果就是1、4。p->foo()和p->fun()则是基类指针指向子类对象，正式体现多态的用法，p->foo()由于指针是个基类指针，指向是一个固定偏移量的函数，因此此时指向的就只能是基类的foo()函数的代码了，因此输出的结果还是1。而p->fun()指针是基类指针，指向的fun是一个虚函数，由于每个虚函数都有一个虚函数列表，此时p调用fun()并不是直接调用函数，而是通过虚函数列表找到相应的函数的地址，因此根据指向的对象不同，函数地址也将不同，这里将找到对应的子类的fun()函数的地址，因此输出的结果也会是子类的结果4。
　　笔试的题目中还有一个另类测试方法。即
B *ptr = (B *)&a; ptr->foo(); ptr->fun();
　　问这两调用的输出结果。这是一个用子类的指针去指向一个强制转换为子类地址的基类对象。结果，这两句调用的输出结果是3，2。
　　并不是很理解这种用法，从原理上来解释，由于B是子类指针，虽然被赋予了基类对象地址，但是ptr->foo()在调用的时候，由于地址偏移量固定，偏移量是子类对象的偏移量，于是即使在指向了一个基类对象的情况下，还是调用到了子类的函数，虽然可能从始到终都没有子类对象的实例化出现。这就是C++中指针的一般用法。

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

总结：隐藏看类型，覆盖（虚函数）看实例。

//小结：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(void)  
{  
    Derived d;  
    Base *pb = &d;  
    Derived *pd = &d;  
    // Good : behavior depends solely on type of the object  
    pb->f(3.14f);   // Derived::f(float) 3.14  
    pd->f(3.14f);   // Derived::f(float) 3.14  
  
    // Bad : behavior depends on type of the pointer  
    pb->g(3.14f);   // Base::g(float)  3.14  
    pd->g(3.14f);   // Derived::g(int) 3   
  
    // Bad : behavior depends on type of the pointer  
    pb->h(3.14f);   // Base::h(float) 3.14  
    pd->h(3.14f);   // Derived::h(float) 3.14  
    return 0;  
}

令人迷惑的隐藏规则
本来仅仅区别重载与覆盖并不算困难，但是C++的隐藏规则使问题复杂性陡然增加。

这里“隐藏”是指派生类的函数屏蔽了与其同名的基类函数，规则如下：

<span style="font-size: 16px;">1) 如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆，重载必须在同一个类中。）。
2) 如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual关键字。此时，基类的函数被隐藏（注意别与覆盖混淆，</span><span style="font-size: 16px; font-family: Arial, Helvetica, sans-serif;"><strong>有virtual关键字则为覆盖</strong>）。</span>

<span style="font-size: 16px; font-family: Arial, Helvetica, sans-serif;"><span style="color: rgb(51, 51, 51); font-family: Verdana; font-size: 14px; line-height: 26px;">上面的程序中：</span><br style="color: rgb(51, 51, 51); font-family: Verdana; font-size: 14px; line-height: 26px;" /><span style="color: rgb(51, 51, 51); font-family: Verdana; font-size: 14px; line-height: 26px;">（1）函数Derived::f(float)覆盖了Base::f(float)。</span><br style="color: rgb(51, 51, 51); font-family: Verdana; font-size: 14px; line-height: 26px;" /><span style="color: rgb(51, 51, 51); font-family: Verdana; font-size: 14px; line-height: 26px;">（2）函数Derived::g(int)隐藏了Base::g(float)，而不是重载。</span><br style="color: rgb(51, 51, 51); font-family: Verdana; font-size: 14px; line-height: 26px;" /><span style="color: rgb(51, 51, 51); font-family: Verdana; font-size: 14px; line-height: 26px;">（3）函数Derived::h(float)隐藏了Base::h(float)，而不是覆盖。</span>
</span>

虚函数

引入原因：为了方便使用多态特性，我们常常需要在基类中定义虚函数。

class Cman

{

public:

virtual void Eat(){……};

void Move();

private:

};

class CChild : public CMan

{

public:

virtual void Eat(){……};

private:

};

CMan m_man;

CChild m_child;

//这才是使用的精髓，如果不定义基类的指针去使用，没有太大的意义

CMan *p ;

p = &m_man ;

p->Eat(); //始终调用CMan的Eat成员函数，不会调用 CChild 的

p = &m_child;

p->Eat(); //如果子类实现(覆盖)了该方法，则始终调用CChild的Eat函数

//不会调用CMan 的 Eat 方法；如果子类没有实现该函数，则调用CMan的Eat函数

p->Move(); //子类中没有该成员函数，所以调用的是基类中的

纯虚函数

引入原因：

1、同“虚函数”；

2、在很多情况下，基类本身生成对象是不合情理的。例如，动物作为一个基类可以派生出老虎、孔雀等子类，但动物本身生成对象明显不合常理。

//纯虚函数就是基类只定义了函数体，没有实现过程定义方法如下

// virtual void Eat() = 0; 直接=0 不要在cpp中定义就可以了

//纯虚函数相当于接口，不能直接实例话，需要派生类来实现函数定义

//有的人可能在想，定义这些有什么用啊，我觉得很有用

//比如你想描述一些事物的属性给别人，而自己不想去实现，就可以定

//义为纯虚函数。说的再透彻一些。比如盖楼房，你是老板，你给建筑公司

//描述清楚你的楼房的特性，多少层，楼顶要有个花园什么的

//建筑公司就可以按照你的方法去实现了，如果你不说清楚这些，可能建筑

//公司不太了解你需要楼房的特性。用纯需函数就可以很好的分工合作了

虚函数和纯虚函数区别

观点一：

类里声明为虚函数的话,这个函数是实现的，哪怕是空实现，它的作用就是为了能让这个函数在它的子类里面可以被重载，这样的话，这样编译器就可以使用后期绑定来达到多态了

纯虚函数只是一个接口，是个函数的声明而已，它要留到子类里去实现。

class A{

protected:

void foo();//普通类函数

virtual void foo1();//虚函数

virtual void foo2() = 0;//纯虚函数

}

观点二：

虚函数在子类里面也可以不重载的；但纯虚必须在子类去实现，这就像Java的接口一样。通常我们把很多函数加上virtual，是一个好的习惯，虽然牺牲了一些性能，但是增加了面向对象的多态性，因为你很难预料到父类里面的这个函数不在子类里面不去修改它的实现

观点三：

虚函数的类用于“实作继承”，继承接口的同时也继承了父类的实现。当然我们也可以完成自己的实现。纯虚函数的类用于“介面继承”，主要用于通信协议方面。关注的是接口的统一性，实现由子类完成。一般来说，介面类中只有纯虚函数的。

观点四：

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

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

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

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

关于实例化一个类：

有纯虚函数的类是不可能生成类对象的，如果没有纯虚函数则可以。比如：
class CA
{
public:
    virtual void fun() = 0;  // 说明fun函数为纯虚函数
    virtual void fun1();
};

class CB
{
public:
   virtual void fun();
   virtual void fun1();
};

// CA，CB类的实现
...

void main()
{
    CA a;   // 不允许，因为类CA中有纯虚函数
    CB b;   // 可以，因为类CB中没有纯虚函数
    ...
}

虚函数在多态中间的使用：

多态一般就是通过指向基类的指针来实现的。

有一点你必须明白，就是用父类的指针在运行时刻来调用子类:

例如，有个函数是这样的：
void animal::fun1(animal *maybedog_maybehorse)
{
maybedog_maybehorse->born();

}
参数maybedog_maybehorse在编译时刻并不知道传进来的是dog类还是horse类，所以就把它设定为animal类，具体到运行时决定了才决定用那个函数。也就是说用父类指针通过虚函数来决定运行时刻到底是谁而指向谁的函数。

用虚函数

#include <iostream.h>

class animal
{
public:
     animal();
     ~animal();
     void fun1(animal *maybedog_maybehorse);
     virtual void born();
};

void animal::fun1(animal *maybedog_maybehorse)
{
     maybedog_maybehorse->born();
}

animal::animal() { }
animal::~animal() { }
void animal::born()
{
     cout<< "animal";
}
///horse
class horse:public animal
{
public:
     horse();
     ~horse();
     virtual void born();
};

horse::horse() { }
horse::~horse() { }
void horse::born()

{
     cout<<"horse";
}
///main
void main()
{
     animal a;
     horse b;
     a.fun1(&b);
}

//output: horse

不用虚函数

#include <iostream.h>
class animal
{
public:
     animal();
     ~animal();
     void fun1(animal *maybedog_maybehorse);
     void born();
};

void animal::fun1(animal *maybedog_maybehorse)
{
     maybedog_maybehorse->born();
}

animal::animal() { }

animal::~animal() { }
void animal::born()
{
     cout<< "animal";
}
horse
class horse:public animal
{
public:
     horse();
     ~horse();
     void born();
};

horse::horse() { }
horse::~horse() { }
void horse::born()

{
     cout<<"horse";
}
main
void main()
{
     animal a;
     horse b;
     a.fun1(&b);
}
// output: animal

虚基类

在说明其作用前先看一段代码

class A

{

public:

int iValue;

} ;

class B: public A

{

public:

void bPrintf(){cout<<"This is class B"<<endl;};

} ;

class C: public A

{

public:

void cPrintf(){cout<<"This is class C"<<endl;};

} ;

class D: public B, public C

{

public:

void dPrintf(){cout<<"This is class D"<<endl;};

} ;

void main()

{

D d;

cout<<d.iValue<<endl; //错误，不明确的访问

cout<<d.A::iValue<<endl; //正确

cout<<d.B::iValue<<endl; //正确

cout<<d.C::iValue<<endl; //正确

}

从代码中可以看出类B C都继承了类A的iValue成员,因此类B C都有一个成员变量iValue ，而类D又继承了B C，这样类D就有一个重名的成员 iValue(一个是从类B中继承过来的，一个是从类C中继承过来的).在主函数中调用d.iValue 因为类D有一个重名的成员iValue编译器不知道调用从谁继承过来的iValue所以就产生的二义性的问题.正确的做法应该是加上作用域限定符 d.B::iValue 表示调用从B类继承过来的iValue。不过类D的实例中就有多个iValue的实例，就会占用内存空间。所以C++中就引用了虚基类的概念，来解决这个问题。

class A

{

public:

int iValue;

} ;

class B: virtual public A

{

public:

void bPrintf(){cout<<"This is class B"<<endl;};

} ;

class C: virtual public A

{

public:

void cPrintf(){cout<<"This is class C"<<endl;};

} ;

class D: public B, public C

{

public:

void dPrintf(){cout<<"This is class D"<<endl;};

} ;

void main()

{

D d;

cout<<d.iValue<<endl; //正确

}

在继承的类的前面加上virtual关键字表示被继承的类是一个虚基类，它的被继承成员在派生类中只保留一个实例。例如iValue这个成员，从类 D这个角度上来看，它是从类B与类C继承过来的，而类B C又是从类A继承过来的，但它们只保留一个副本。因此在主函数中调用d.iValue时就不会产生错误。

虚函数

还是先看代码

class A

{

public:

void funPrint(){cout<<"funPrint of class A"<<endl;};

} ;

class B: public A

{

public:

void funPrint(){cout<<"funPrint of class B"<<endl;};

} ;

void main()

{

A *p; //定义基类的指针

A a;

B b;

p=&a;

p->funPrint();

p=&b;

p->funPrint();

}

大家以为这段代码的输出结果是什么？有的人可能会马上回答funPrint of class A 与 funPrint of class B 因为第一次输出是引用类A的实例啊，第二次输出是引用类B的实例啊。那么我告诉你这样想就错啦，答案是funPrint of class A 与 funPrint of class A 至于为什么输出这样的结果不在本文讨论的范围之内；你就记住，不管引用的实例是哪个类的当你调用的时候系统会调用左值那个对象所属类的方法。比如说上面的代码类A B都有一个funPrint 函数，因为p是一个A类的指针，所以不管你将p指针指向类A或是类B，最终调用的函数都是类A的funPrint 函数。这就是静态联篇，编译器在编译的时候就已经确定好了。可是如果我想实现跟据实例的不同来动态决定调用哪个函数呢？这就须要用到虚函数（也就是动态联篇）

class A

{

public:

virtual void funPrint(){cout<<"funPrint of class A"<<endl;};

} ;

class B: public A

{

public:

virtual void funPrint(){cout<<"funPrint of class B"<<endl;};

} ;

void main()

{

A *p; //定义基类的指针

A a;

B b;

p=&a;

p->funPrint();

p=&b;

p->funPrint();

}

在基类的成员函数前加virtual关键字表示这个函数是一个虚函数，所谓虚函数就是在编译的时候不确定要调用哪个函数，而是动态决定将要调用哪个函数，要实现虚函数必须派生类的函数名与基类相同，参数名参数类型等也要与基类相同。但派生类中的virtual关键字可以省略，也表示这是一个虚函数。下面来解决一下代码，声明一个基类的指针（必须是基类，反之则不行）p，把p指向类A的实例a，调用funPrint函数，这时系统会判断p所指向的实例的类型,如果是A类的实例就调用A类的funPrint函数，如果是B类的实例就调用B类的funPrint函数。

纯虚函数

与其叫纯虚函数还不如叫抽象类,它只是声明一个函数但不实现它，让派生类去实现它,其实这也很好理解。

class Vehicle

{

public:

virtual void PrintTyre()=0; //纯虚函数是这样定义的

} ;

class Camion: public Vehicle

{

public:

virtual void PrintTyre(){cout<<"Camion tyre four"<<endl;};

} ;

class Bike: public Vehicle

{

public:

virtual void PrintTyre(){cout<<"Bike tyre two"<<endl;};

} ;

void main()

{

Camion c;

Bike b;

b.PrintTyre();

c.PrintTyre();

}

如上代码，定义了一个交通工具类（Vehicle），类中有一函数可打印出交通工具的轮胎个数，但交通工具很多轮胎个数自然也就不确定，所以就把它定义为纯虚函数,也就是光定义函数名不去实现它，类Camion继承了Vehicle并实现了里面的代码，打印出有4个轮胎。Bike类也是一样。有一点须要注意一下，纯虚函数不能实化化，但可以声明指针。

总结

    虚基类
    1, 一个类可以在一个类族中既被用作虚基类，也被用作非虚基类。
    2, 在派生类的对象中，同名的虚基类只产生一个虚基类子对象，而某个非虚基类产生各自的子对象。
    3, 虚基类子对象是由最派生类的构造函数通过调用虚基类的构造函数进行初始化的。
    4, 最派生类是指在继承结构中建立对象时所指定的类。
    5, 派生类的构造函数的成员初始化列表中必须列出对虚基类构造函数的调用；如果未列出，则表示使用该虚基类的缺省构造函数。
    6, 从虚基类直接或间接派生的派生类中的构造函数的成员初始化列表中都要列出对虚基类构造函数的调用。但只有用于建立对象的最派生类的构造函数调用虚基类的构造函数，而该派生类的所有基类中列出的对虚基类的构造函数的调用在执行中被忽略，从而保证对虚基类子对象只初始化一次。
    7, 在一个成员初始化列表中同时出现对虚基类和非虚基类构造函数的调用时，虚基类的构造函数先于非虚基类的构造函数执行。

    虚函数
    1, 虚函数是非静态的、非内联的成员函数，而不能是友元函数，但虚函数可以在另一个类中被声明为友元函数。
    2, 虚函数声明只能出现在类定义的函数原型声明中，而不能在成员函数的函数体实现的时候声明。
    3, 一个虚函数无论被公有继承多少次，它仍然保持其虚函数的特性。
    4, 若类中一个成员函数被说明为虚函数，则该成员函数在派生类中可能有不同的实现。当使用该成员函数操作指针或引用所标识的对象时，对该成员函数调用可采用动态联编。
    5, 定义了虚函数后，程序中声明的指向基类的指针就可以指向其派生类。在执行过程中，该函数可以不断改变它所指向的对象，调用不同版本的成员函数，而且这些动作都是在运行时动态实现的。虚函数充分体现了面向对象程序设计的动态多态性。纯虚函数版本的成员函数，而且这些动作都是在运行时动态实现的。虚函数充分体现了面向对象程序设计的动态多态性。

    纯虚函数
    1, 当在基类中不能为虚函数给出一个有意义的实现时，可以将其声明为纯虚函数，其实现留待派生类完成。
    2, 纯虚函数的作用是为派生类提供一个一致的接口。
    3, 纯虚函数不能实化化，但可以声明指针。