虚函数为了重载和多态的需要,在基类中是由定义的,即便定义是空,所以子类中可以重写也可以不写基类中的函数!

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

虚函数

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

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,是一个好的习惯,虽然牺牲了一些性能,但是增加了面向对象的多态性,因为你很难预料到父类里面的这个函数不在子类里面不去修改它的实现

观点三:

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

观点四:

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

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

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



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

2.关于实例化一个类: 
有纯虚函数的类是不可能生成类对象的,如果没有纯虚函数则可以。比如: 
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中没有纯虚函数 
    ... 


3.虚函数在多态中间的使用: 
   多态一般就是通过指向基类的指针来实现的。 

4.有一点你必须明白,就是用父类的指针在运行时刻来调用子类: 
例如,有个函数是这样的: 
void animal::fun1(animal *maybedog_maybehorse) 

     maybedog_maybehorse->born();

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

5.用虚函数 
#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

6.不用虚函数 
#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, 纯虚函数不能实化化,但可以声明指针。