virtual学习

// virtual学习.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>

class father
{
public:
    father(){};
    // 析构为纯虚函数，防止派生类析构不完整
    virtual ~father() = default;
    // 基类自定义构造函数
    father(int Num)
        :m_nNum(Num)
    {
        
    }
public:
    void notVirtualFunc()
    {
        std::cout << "father not Virtual Func!" << std::endl;
    }
    virtual void VirtualFunc()
    {
        std::cout << "father Virtual Func!" << std::endl;
    }
    virtual void SonVirtualFunc() = 0;
private:
    int m_nNum;
};

class son 
    :public father
{
public:
    son(){};
    ~son(){};
    son(int Num1, int Num2) :
        father(Num1), m_nSonNum(Num2)
    {

    }
public:
    void notVirtualFunc()
    {
        std::cout << "son not Virtual Func!" << std::endl;
    }
    void  VirtualFunc()
    {
        std::cout << "son Virtual Func!" << std::endl;
    }
    void SonVirtualFunc()
    {
        std::cout << "son SonVirtual Func!" << std::endl;
    }
    int m_nSonNum;
};

class grandson final // 加final表示不可以被继承
    :public son
{
public:
    grandson(){};
    ~grandson(){};
    // 派生类构造函数只初始化它的直接基类，即不能用father的构造函数初始化grandson
    grandson(int Num1, int Num2, int Num3)
        :son(Num1, Num2), m_nGrandsonNum(Num3)
    {

    }
public:
    void notVirtualFunc()
    {
        std::cout << "grandson not Virtual Func!" << std::endl;
    }
    void  VirtualFunc() override    // 保证派生类重写基类函数
    {
        std::cout << "grandson Virtual Func!" << std::endl;
    }
    void SonVirtualFunc()
    {
        std::cout << "grandson SonVirtual Func!" << std::endl;
    }
    int m_nGrandsonNum;
};

void Print(father&f)
{
    f.notVirtualFunc();
    f.VirtualFunc();
    f.SonVirtualFunc();
    // 强调基类，回避虚函数的机制，只调用基类函数，不管子类动态绑定
    f.father::VirtualFunc();
    std::cout << std::endl;
}

int _tmain(int argc, _TCHAR* argv[])
{
    // 含有纯虚函数时，相当于一个函数接口，不能创建实例
    //father f;
    son s(9, 8);
    grandson g(1, 2, 3);

    //Print(f);
    // 发生动态绑定时，如果基类成员函数定义为virtual，则会调派生类的函数，对基类进行覆盖；否则直接继承父类函数，不进行改变
    // 不管多少层继承，只要father基类定义的为非virtual，则所有子孙调用的都是基类的函数
    // father 定义为virtual，son相同的函数定义为virtual或非virtual，grandson发生动态绑定时，所调用的函数为grandson自己的函数
    Print(s);
    Print(g);
    system("pause");
	return 0;
}

根据C++Primer学习，后续可能补充