多态

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

using namespace std;
class A
{
public:
void f1()
{
    printf("f1aaa  ");
}

void f2()
{
    printf("f2aaa  ");
}


int f3(int a)
{
    printf("f3aaa  ");
    return 0;

}


};
class B :public A
{
public:
virtual void f1()
{
    printf("f1bbb  ");
}


virtual void f2()
{
    printf("f2bbb  ");  
}


virtual int f3(int a)
{
    printf("f3bbb  ");
    return 0;

}

};

typedef void(*FUN)(void); 

int main()
{
   
    B b;    
    A* a = &b;

    /*
    A aa;
    long** p = (long**)&aa;
    FUN fun = (FUN)p[0][0];
    fun();*/
    // FUN fun;
    
    // long**p1 = (long**)&b;
    // fun = (FUN)p1[0][0];
    // fun();
    // fun = (FUN)p1[0][1];
    // fun();
    // fun = (FUN)p1[0][2];
    // fun();
    a->f3(1); //b.aaa();
    return 0; 
}

 

父类指针指向子类对象：
　　父类中是虚函数 子类中是普通函数 当继承后子类同名同参数的函数 会自动变成虚函数 既然变成了虚函数 就会覆盖父类的同名同参数的虚函数，那么调用的子类中的函数

　　当父类中是普通函数 子类中是虚函数 继承后子类相同函数会变成普通函数，普通函数就会调用父类的函数，

 　   普通函数并不会重写覆盖，虚函数会覆盖，所以普通函数不管是重写还是重载调的是父类中的函数，普通函数只会被当成重载，这里跟java有区别

 

 

普通函数不在虚表中：

虚函数中父类中：

　　子类普通函数全部转成虚函数，并覆盖父类虚函数

虚函数中子类中 ：　

　　子类函数还是会直接覆盖父类的函数，从虚表中取的依旧是子类中的函数 这跟直接用对象调用不同

虚函数在父类中也在子类中

　　如果函数名和参数都相同 那么就是直接覆盖，如果子类中有个函数是重载的，那么重载的函数也会在虚表中

 

 

 

 

 func中又调用了Serialize()

 

 转成基类的时候调用了拷贝构造