C++ 虚函数与多态

#include <iostream>
using namespace std;

/*-----------------------
2012年11月10日 01:26:17
------------------------*/

/**************************************************************
虚函数：
    1、在基类用【virtual声明】的成员函数即为虚函数
    2、在派生类中的定义此函数，要求
        函数名、函数类型、函数参数个数和类型全部与基类的虚函数相同
        并根据派生类的需要重新定义函数体
    3、当一个成员函数声明为虚函数后，其派生类中的同名函数都自动成为虚函数，无论是否加virtual关键字
    4、用基类的指针或引用指向派生类的对象
       通过用基类的指针或引用调用虚函数
       实际执行的将使派生类对象中定义的虚函数

虚函数表：
    1、如果类中包含有虚成员函数，在用该类实例化对象时，
    对象的第一个成员将是一个指向虚函数表的指针[pvftable]。
    2、虚函数表记录运行过程中实际应该调用的虚函数的入口地址
    3、类中所有的虚函数形成虚函数表
        [可以通过调试查看：
            cout<<sizeof(aa3)<<endl;]

虚析构函数： -- 防止内存泄漏
    1、如果一个基类的指针指向派生类的对象，
    并且想通过该指针delete派生类对象，
    系统将只会执行基类的析构函数
    而不会执行派生类的析构函数
    2、为避免这种情况的发生，往往把析构函数声明为虚的，
    此时，系统将 先执行派生类对象的析构函数
    然后再执行基类的析构函数
    3、如果基类的析构函数声明为虚的，
    派生类的析构函数也将自动成为虚构函数
    无论派生类析构函数声明中是否加virtual
    4、防止内存泄漏
    当派生类中有指针时，对象销毁时，
    也需要释放指针所指向的地址
    5、特别注意：
        5.1、
        基类名*  指针 = new 子类名();
            只有当一个父类类型的指针 指向 子类对象[new 的对象]时
            只有将 基类的析构函数 声明为 虚函数virtual  
        在 delete 指针时-->
            才会：
                先执行派生类对象的析构函数
                然后再执行基类的析构函数
            否则：
                只执行基类的析构函数
        5.2、
        类名*  指针 = new 类名();
            当指针的类型是对象类型的本身时
        在 delete 指针时-->
                基类的析构函数 【不是】虚函数virtual  
            也会：
                先执行派生类对象的析构函数
                然后再执行基类的析构函数
        5.3、在栈中分配分配空间时【子类分配空间】
            5.3.1、不需要 delete
                在 该区域 执行完后 会自动释放 该栈空间
            5.3.2、基类的析构函数 【不是】虚函数virtual  
            也会：
                先执行派生类对象的析构函数
                然后再执行基类的析构函数

纯虚函数和抽象类：
    1、纯虚函数具有如下的一般形式：
        virtual 返回类型 函数名(参数列表)=0;
    2、纯虚函数没有函数体，即只有函数的声明而没有函数的定义
    3、通常在基类中声明纯虚函数，在派生类中定义该虚函数
    如果派生类中也没有定义该纯虚函数，则该函数在派生类中任然为纯虚函数
    4、不能实例化对象的类称为[抽象类]，
    具有纯虚函数的类是不能被实例化对象的
    所以具有纯虚函数的类是一种抽象类
    5、虽然抽象类不能实例化对象，但是可以用抽象类的指针指向派生类对象
    并调用派生类的虚函数的实际实现
    6、子类在继承抽象类时：
    必须全部实现抽象类的 纯虚函数，该派生类才能被实例化
    如果只实现部分 纯虚函数，则该派生类还是 抽象类
    7、当一个的所有函数都是 纯虚函数，
    则该类就是 接口【C++没有接口】
    接口是抽象类的一种特例

子类调用基类的函数：
    基类类名::函数名();

多态：
    1、父类的函数为 虚函数, 即在 返回类型前加 virtual
        virtual void Print(){.....};
    2、子类对该函数进行重写[返回类型 和 函数名 相同]
        void Print(){......};
    3、父类的[指针]指向父类对象或子类对象
        //通过指针
            void test1(a* temp){
                temp->Print();
            }
        3.1、在 【栈中】 分配空间
            父类名* 地址变量名 =  &父类名[子类名]();
                a* aa = &b();
                //等价于
                    a* aa;
                    b bb;  
                    aa=&bb;
                
                test1(aa);
        3.2、在 【堆中】 分配空间
            父类名* 地址变量名 = new 父类名[子类名]();
                a* cc = new c();
                test1(cc);

注意点：
    1、指针调用函数的方式：
        指针名->函数名();
    2、引用调用函数的方式：
        引用名.函数名();
    3、继承方式
        class 子类名:public 父类名{....};
***************************************************************/

class Person{ //抽象类
public:
    char* name;
public:
    virtual void Eat()=0;
    virtual void Sleep()=0;
};

class Stu:public Person{
public:
    void Eat(){
        cout<<"Eat......."<<endl;
    }
    void Sleep(){
        cout<<"Sleep.........."<<endl;
    }
};

void main(){
    Person* person = new Stu();
    person->Eat();
}

class a{
public:
    virtual void Print(){
        cout<<"a............."<<endl;
    }
    virtual void Prafint(){
        cout<<"a............."<<endl;
    }
public:
    a(){
        cout<<"new a............"<<endl;    
    }
public:
    virtual ~a(){
        cout<<"destory a............"<<endl;
    }
};

//通过指针
void test1(a* temp){
    temp->Print();
}

//通过引用
void test2(a& temp){
    temp.Print();
}

class b:public a{
public:
    void Print(){
        cout<<"b............."<<endl;
    }
public:
    b(){
        cout<<"new b............"<<endl;    
    }
public:
    ~b(){
        cout<<"destory b............"<<endl;
    }
};

class c:public a{
public:
    void Print(){
        cout<<"c............."<<endl;
    }
public:
    c(){
        cout<<"new c............"<<endl;    
    }
public:
    ~c(){
        cout<<"destory c............"<<endl;
    }
};

void test22(){
     
     /*
        b bb;
        注意：
            在栈中实例化 派生类
            1、先 调用父类的 构造函数 再调用派生类的构造函数
            2、不需要手动释放内存
            3、在 该 区域执行完后 会自动释放内存空间
        new a............
        new b............
        destory b............
        destory a............
     */
     //a aa = bb;
    //aa.Print();
    a* aa = new b();
    //a* aa = new b();  
    //aa->Print();
    delete aa;
    /*
    a* aa = new b();
    在堆中分配空间：
        1、先 调用父类的 构造函数 再调用派生类的构造函数
        2、先调用派生类的析构函数 再调用基类的析构函数
            2.1、2的满足条件：需要把 基类的析构函数 声明 虚函数
        3、如果基类的 析构函数 不是虚函数
            3.1、在 delete 时只会调用基类的析构函数
    */
    /*
    new a............
    new b............
    b.............
    destory b............
    destory a............
    */
}

int test11(){
    /*通过指针*/
    a* aa1 = &b();
    /*等价于
        a* aa1;
        b bb;  
        aa1=&bb;
    */
    test1(aa1);
    a* cc1 = new c(); //动态绑定  就是虚函数中的内容 在实例化的时候动态载入
    test1(cc1);
    
    /*通过引用*/
    a& aa2 = b();
    test2(aa2);
    a* cc2 = new c();
    test1(cc2);

    a aa3;
    cout<<sizeof(aa3)<<endl;

    //cout<<&(a::Print)<<endl;
    /*
    //打印函数的地址
        printf("a::Print=%x\n", &(a::Print));
        printf("b::Print=%x\n", &(b::Print));
        printf("c::Print=%x\n", &(c::Print));
    
    打印结果：
        a::Print=401271
        b::Print=401271
        c::Print=401271    
    分析：
            a
           / \
          b   c
        1、b继承a , c继承a
        2、Print()在a类中是 虚函数
        3、类b类c 重写了a的虚函数，所以该函数也为虚函数
        4、三个类中的函数统一载入一个地址区：
            意味着三个只能有一个存在
        5、具体 401271 里面的内容就由调用的实例在实例化的时候动态载入
    */
    return 0;
}