C++：virtual关键字

从很多代码中，经常看到virtual的使用
如：

virtual ~StereoMatch(void);

学习virtual关键字：
浅析c++中virtual关键字
1.virtual关键字主要是什么作用？

• c++中的函数调用默认不适用动态绑定。要触发动态绑定，必须满足两个条件：第一，指定为虚函数；第二，通过基类类型的引用或指针调用。由此可见，virtual主要功能是实现动态绑定。

2.那些情况下可以使用virtual关键字？

• virtual可用来定义类函数和应用到虚继承。
• 友元函数 构造函数 static静态函数 不能用virtual关键字修饰；
• 普通成员函数 和析构函数 可以用virtual关键字修饰；

virtual ~StereoMatch(void);

3.virtual函数的效果：

class GrandFather //祖父类
{  
public:  
    GrandFather() {}  //构造函数
    virtual void fun()  //虚函数声明定义
    {  
        cout << "GrandFather call function!" << endl;  
    }  
};  

class Father : public GrandFather//父类，公有继承祖父类 
{  
public:  
     Father() {}  //构造函数
     void fun()   //fun函数声明定义
     {  
         cout << "Father call function!" << endl;  
     }  
};  


class Son : public Father  //子类，公有继承父类
{  
public:  
    Son() {}  //构造函数
    void fun()  //fun函数声明定义
    {  
        cout << "Son call function!" << endl;  
    }  
};  

void print(GrandFather* father) //输出函数 ，祖父类形参
{  
    father->fun();  //调用fun函数
}  

int _tmain(int argc, _TCHAR* argv[])  
{  
    Father * pfather = new Son;//建立一个父类的指针让它指向子类
    pfather->fun();  
    GrandFather * pgfather = new Father;  
    print(pgfather); //祖父类指针变量 
    return 0;  
}  

• 输出为 Son call function – Father call function

4.virtual的继承性

• 只要基函数定义了virtual，继承类的该函数也就具有virtual属性；即 GrandFather， Father ，Son同时定义virtual void fun()与GrandFather一个定义virtual void fun效果是一样的

5.虚析构函数

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

    ~GrandFather()   //析构函数
    {  
        cout << "GrandFather destruction!" << 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() {}  
    void fun()  
    {  
        cout << "Son call function!" << endl;  
    }  

     ~Son()    //析构函数
    {  
        cout << "Son destruction!" << endl;  
    }  
};  

void print(GrandFather* p)  
{  
    p->fun();  
}  

int _tmain(int argc, _TCHAR* argv[])  
{  
    Father * pfather = new Son;  
    delete pfather;  
    return 0;  
}  

• 以上代码输出：Father destruction!
  GrandFather destruction!
  执行了Son的构造函数，没执行Son的析构函数，故把GrandFather的析构函数设置为virtual
  则输出: Son destruction!
  Father Destruction!
  GrandFather destruction!

• 故在基类调加virtural虚析构函数，所以的派生类的析构函数都执行；否则，派生类的析构函数不执行；

• 纯虚函数
  纯虚函数定义如下：

class GrandFather  //祖父类
{  
public:  
    GrandFather() {}  //构造函数
    virtual void fun() = 0  //纯虚函数
    {  
        cout << "GrandFather call function!" << endl;  
    }  

    virtual ~GrandFather()   //虚析构函数
    {  
        cout << "GrandFather destruction!" << endl;  
    }  
};  

• 纯虚函数为后代派生类提供可覆盖的接口，但这个类中的版本决不会调用。
• 含有（或继续）一个或多个纯虚函数的类是抽象基类，抽象基类不能实例化！
• 继承类只有重写这个接口才能被实例化

7.虚继承
虚继承主要解决交叉继承带来的问题。
C++虚继承：

class GrandFather  //祖父类；
{  
public:  
    GrandFather() {}//构造函数  
    void fun()  //fun函数
    {  
        cout << "GrandFather call function!" << endl;  
    }  

    virtual ~GrandFather()  //虚析构函数 
    {  
        cout << "GrandFather destruction!" << endl;  
    }  
};  

class Father1 : public GrandFather  //多继承，父类1
{  
public:  
    Father1() {}  
    void fun()  
    {  
        cout << "Father call function!" << endl;  
    }  

};  

class Father2 : public GrandFather// 多继承，父类2 
{  
public:  
    Father2() {}  
    void fun()  
    {  
        cout << "Father call function!" << endl;  
    }  

};  


class Son : public Father1, public Father2 
//子类多继承，父类1 ，父类2
{  
public:  
    Son() {}  
    //void fun()  
    //{  
    //  cout << "Son call function!" << endl;  
    //}  
};  

void print(GrandFather* p)  
{  
    p->fun();  
}  

int _tmain(int argc, _TCHAR* argv[])  
{  
    Son* son = new Son;  
    son->fun();  
    return 0;  
}  

编译时会提示报错，对fun的访问不明确如果Father1和Father2都用虚继承继承GrandFather类则可以解决这个问题。

8.构造函数和析构函数中的虚函数：
如果在构造函数或析构函数中调用虚函数，则运行的是为构造函数或析构函数自身类型定义的版本

class classA  //classA类
{  
 public:  
    classA()  //构造函数
    {  
        clear();  //构造函数中调用clear函数
    }  
    virtual ~classA()  //classA虚析构函数
    {  
    }  
    void clear()  //clear函数定义
    {  
        memset(this , 0 , sizeof(*this));  
    }  
    virtual void func()  //虚函数func定义
    {  
        printf("func\n");  
    }  
};  

class classB : public classA  //派生类classB
{  
};  

int main(void)  
{  
    classA oa;  //classA类类型oa
    classB ob;  //classB类类型ob
    classA * pa0 = &oa;  //类类型指针变量
    classA * pa1 = &ob;  
    classB * pb = &ob;  
    oa.func(); // 调用classA的func函数
    ob.func(); // 调用classB的func函数，classB完全继承classA；执行classA的func函数
    pa0->func(); // 3  
    pa1->func(); // 4  
    pb->func(); // 5  
    return 0;  
}  

补充一个例子，这个程序输出依次是
func
func
出错
func
func
谈谈我的理解，

• 当classA oa;oa.func();不存在动态调用的过程，所以func虽然是虚函数，但是函数调用不通过虚表访问，所以即使memset(this , 0 , sizeof(*this));找不到虚表地址也没有关系
• 在执行classB ob;的时候，注意memset的是classA的地址，所有ob的虚表是存在的；即是如下，通过指针或引用（动态绑定）访问oa的func函数（需要从虚表访问），会出错访问ob的func和函数，无论静态访问还是动态访问，都不会出错
• 当把classB的代码改成如下时：

class classB : public classA

<pre name="code" class="cpp" style="font-weight: bold;">{</pre><pre name="code" class="cpp" style="font-weight: bold;">        
classB()
    {
        clear();
    }
    virtual ~classB()
    {
    }
    void clear()
    {
        memset(this , 0 , sizeof(*this));
    }</pre><br>
<pre></pre>
<pre name="code" class="cpp" style="font-weight: bold;">};</pre>输出为

func
func
出错
出错
出错