1、子类和父类返回值参数相同，函数名相同，有virtual关键字，则由对象的类型决定调用哪个函数。
2、子类和父类只要函数名相同，没有virtual关键字，则子类的对象没有办法调用到父类的同名函数,父类的同名函数被隐藏了，也可以强制调用父类的同名函数class::funtion_name。
3、子类和父类参数不同，函数名相同，有virtual关键字，则不存在多态性，子类的对象没有办法调用到父类的同名函数,父类的同名函数被隐藏了，也可以强制调用父类的同名函数class::funtion_name。
4、子类和父类返回值不同，参数相同，函数名相同，有virtual关键字，则编译出错error C2555编译器不允许函数名参数相同返回值不同的函数重载。
实际上这种属于设计错误，不管是父虚子实还是子实父虚。父虚的话，子类即使没有加virtual也会默认加（是否是在编译的时候自动更改？）。而如果子虚父实，则起不到任何多态的作用，所以设计错误，跟不加virtual一样，那为何要加

但是不管是否是需函数，仍然可以通过加 父类::函数名 来调用父类的函数

而如果是有虚函数，那么通过给父类指针赋子类对象地址或通过父类引用
子类对象时，调用虚函数都是子类的虚函数。
但是大小仍然是父类对象的大小，而且仍然可以通过作用域方式调用父类虚函数。而且如果父类有虚函数的话，内存会多4字节。
//从另一方面讲，虚函数有点像static，只被初始化一次。

#include <iostream>
#include <Windows.h>

using namespace std;

class Father
{
    
    
public:
    virtual void Face()
    {
    
    
        cout << "Father's face" << endl;
    }

    void Say()
    {
    
    
        cout << "Father say hello" << endl;
    }

public:
    int m;
};

class Son : public Father
{
    
    
public:
    virtual void Face()
    {
    
    
        cout << "son's face" << endl;
    }
    void Say()
    {
    
    
        cout << "Son say hello" << endl;
    }

public:
    int n;
};
int main()
{
    
    
    Son son1, son2;
    Father f3, f1 = son2;
    f3 = son2;
    Father *f2 = &son1; 
    Father &f4 = son1;
    Son *son3=&son2;
    Father *f5 = (Father *)&son2;


    cout << "FatherSize   " << sizeof(Father) << "Son Size     " << sizeof(Son)<<endl;
    cout << "SonSize   " << sizeof(son1) << "F1     " << sizeof(f1)<<endl;
    cout << "F2   " << sizeof(*f2) << "F3     " << sizeof(f3)<<endl;
    cout << "F4   " << sizeof(f4) << "F3     " << sizeof(*f5)<<endl;
    cout<<"f1.say"<<endl;
    f1.Say();f1.Face();
    cout<<"f2.say"<<endl;
    f2->Say();f2->Face();f2->Father::Face();
    cout<<"f3.say"<<endl;
    f3.Say();f3.Face();
    cout << "f4.say" << endl;
    f4.Say();
    f4.Face();f4.Father::Face();f4.m;
    cout << "f5.say" << endl;
    f5->Say();
    f5->Face();
    f5->Father::Face();
    return 0;
}