c++ 中的virtual

1:virtual关键字主要有什么作用

　　c++中的函数调用默认不适用动态绑定，要触发动态绑定，必须满足两个条件：第一指定为虚函数; 第二通过基类类型的引用或指针调用。

2：哪些情况下可以使用virtual关键字呢

　　virtual可用来定义类函数和应用到虚继承中

注意：有元函数、构造函数、static静态函数不能用virtual关键字修饰。普通成员函数和析构函数可以用virtual关键字修饰。

举一个例子：

#include "stdafx.h"
#include<stdlib.h>
#include<iostream>
using namespace std;

class GrandFather
{
public:
    GrandFather() {}
    virtual void fun()
    {
        cout << "GrandFather call function" << endl;
    }
};

class Father:public GrandFather
{
public:
    Father() {}
    void fun()
    {
        cout << "Father call function"<< endl;
    }
};

class Son : public Father
{
public:
    Son() {}
    void fun()
    {
        cout << "Son call function" << endl;
    }
};

void Print( GrandFather* father )
{
    father->fun();
}

int main(int argc, _TCHAR* argv[])
{
    Father* pfather = new Son;
    pfather->fun();

    GrandFather* grandfather = new Father;
    Print(grandfather);

    return 0;
}

3:virtual的继承性

　　只要虚基类定义了virtual，继承类的该函数也就有virtual属性。

即GrandFather Father Son同时定义了virtual void fun() 与 GrandFather 一个定义virtual void fun效果是一样的。

4：虚析构函数

#include "stdafx.h"
#include<stdlib.h>
#include<iostream>
using namespace std;

class GrandFather
{
public:
    GrandFather() {}
    virtual void fun()
    {
        cout << "GrandFather call function" << endl;
    }
    ~GrandFather()
    {
        cout << "GrandFather dstruction " << endl;
    }
};

class Father:public GrandFather
{
public:
    Father() {}
    void fun()
    {
        cout << "Father call function"<< endl;
    }
    ~Father()
    {
        cout << " Father destruction " << endl;
    }
};

class Son : public Father
{
public:
    Son() { cout << "son hello" << endl; }
    void fun()
    {
        cout << "Son call function" << endl;
    }
    ~Son()
    {
        cout << " Son destruction " << endl;
    }
};

void Print( GrandFather* father )
{
    father->fun();
}

int main(int argc, _TCHAR* argv[])
{
    //Father* pfather = new Son;
    //pfather->fun();

    //GrandFather* grandfather = new Father;
    //Print(grandfather);

    Father* father = new Son;
    delete father;
    return 0;
}

运行结果为：

我们发现执行了Son的构造函数，没执行Son的析构函数，故把GrandFather的析构函数设置为virtual，如下例：

#include "stdafx.h"
#include<stdlib.h>
#include<iostream>
using namespace std;

class GrandFather
{
public:
    GrandFather() {}
    virtual void fun()
    {
        cout << "GrandFather call function" << endl;
    }
    virtual ~GrandFather()
    {
        cout << "GrandFather dstruction " << endl;
    }
};

class Father:public GrandFather
{
public:
    Father() {}
    void fun()
    {
        cout << "Father call function"<< endl;
    }
    ~Father()
    {
        cout << " Father destruction " << endl;
    }
};

class Son : public Father
{
public:
    Son() { cout << "son hello" << endl; }
    void fun()
    {
        cout << "Son call function" << endl;
    }
    ~Son()
    {
        cout << " Son destruction " << endl;
    }
};

void Print( GrandFather* father )
{
    father->fun();
}

int main(int argc, _TCHAR* argv[])
{
    //Father* pfather = new Son;
    //pfather->fun();

    //GrandFather* grandfather = new Father;
    //Print(grandfather);

    Father* father = new Son;
    delete father;
    return 0;
}

5：纯虚函数

纯虚函数的定义如下：

class CVirtual

{

public:

    CVirtual() {}

    virtual void fun() = 0

    {

        cout << " CVirtual call function " << endl;

    }

    virtual ~CVirtual()

    {

        cout << " CVirtual destruction " << endl;

    }

};

 

纯虚函数为后代类提供可覆盖的接口，但这个类中的版本决不会调用。

含有（或继续）一个或多个纯虚函数的类是抽象基类，抽象基类不能实例化！

继承类只有重写这个接口才能被实例化.

 

这也许会让人联想到函数的重载，但是我们一比较就会发现两者是完全不同的。

1):重载的几个函数必须在同一个类中。而覆盖的函数必须在有继承关系的不同的类中。

2):覆盖的几个函数必须函数名、参数、返回值都相同。而重载的函数必须函数名相同，参数不同。参数不同的目的就是为了在函数调用的时候编译器能够通过参数来判断程序是在调用哪个函数。这也很自然的解释了为什么函数不能通过返回值类重载，因为程序在调用函数时很有可能不关心返回值的，编译器就无法从代码中看出程序在调用哪个函数了。

3):覆盖的函数前必须加关键字virtual;重载和virtual没有任何瓜葛，加不加都不影响重载的运作。