（九）继承三

（九）继承三
2016 6 29
重点内容
五、虚函数
1、当父类指针或引用指向子类对象，而子类中又覆盖了父类的函数，希望用父类指针或引用，调用到正确版本的函数，需要把该成员函数声明为虚函数。（普通函数：父类指针、引用不管父类、子类，调用函数都是父类。虚函数：调用函数为指向对象函数。）

1.1、当父类成员函数是虚函数（virtual) ,类中重写的函数默认为虚函数

2、有了虚函数以后，无需向下转型，就可以正确的用父类的指针或引用，调用到子类banben的函数。

3、虚析构函数：如果一个类有子类，则这个类的（父类）的析构函数必须是虚函数，即虚析构

（ 原因：）
如果父类的析构不是虚析构，则当（用delete）删除一个指向子类对象的父类指针时，将调用父类版本的析构函数，子类只释放了来自于父类的那部分成员变量，而子类自己扩展的成员没有被释放，造成内存泄漏 。

5、动态绑定：虚函数被调用的时候，到底调用哪个版本，在编译时无法确定，只有在执行的时候才能确定，称为动态绑定。

6、绑定使得程序可以照顾到未来增加的代码，比如创建一个新的子类，并在子类中覆盖了父类的虚函数。用之前的父类指针，依然可以正确的调用到子类里的函数，而无需对旧代码进行更改。

六、多态的代价
（类占用空间大小由成员变量决定（除以外static））虚指针也会占用空间大小，8个字节。
1、多态：用父类指针或引用，统一操作各种子类对象

2.为了实现动态绑定，编译器会生成一个虚拟表（虚函数，存储虚函数的地址）为每个类包含至少一个虚函数。这个类的每个对象中，一个数据成员被增加：这个类的虚函数表指针，称为虚指针。
当虚函数被调用时，编译器会使用该对象中的虚指针来查找虚函数表，然后遍历虚函数表，以查找到虚函数的指针（地址），最终找到正确版本的函数。

3、多态的代价：
类添加虚函数，会自动创建一个虚指针，虚指针会指向一个虚函数表（虚函数表存储（地址）），表中指针指向了每一个虚函数。
（1.增加内存 （类占用空间大小由成员变量决定（除以外static））虚指针也会占用空间大小，8个字节。不管有多少虚指针，都只增加8个字节的内存。

2.程序运行速度减慢（10%~20%））

#include <iostream>
using namespace std;
class Base{
public:
   virtual void print(){
       cout<<"父类被调用"<<endl;
    }
};
class Derived1:public Base{
public:
    void print(){
        cout<<"子类1被调用"<<endl;
    }
};
class Derived2:public Base{
public:
    void print(){
    cout<<"子类2被调用"<<endl;
    }
};
int main(int argc, const char * argv[]) {
    Base b1;
    Derived1 d1;
    Derived2 d2;

    b1=d1;
    b1.print();

    Base &b2=b1;
    b2.print();

    Base &b3=d1;
    b3.print();

    Base &b4=d2;
    b4.print();

    Base *pb=&d1;
    pb->print();
    pb=&d2;
    pb->print();

        return 0;
}
/*

 父类被调用
 父类被调用
 子类1被调用
 子类2被调用
 子类1被调用
 子类2被调用*/

七、抽象基类与纯虚函数
1、纯虚函数：函数=0就是一个纯虚函数，纯虚函数没有函数体，不需要事先。在子类里事先虚函数的具体功能。

2、抽象基类：拥有虚函数函数的类叫做抽象类，抽象类只能作为基类，不能构建对象。因为抽象……

3、纯虚函数被定义在派生类中。如果派生类不重写基类的纯虚函数，则将纯虚函数继承为派生类的纯虚函数。因此，派生类也是一个抽象类

#include <iostream>
using namespace std;
class A{
protected:
    int a1;
    int a2;
public:
    A(int _a1,int _a2){
        a1=_a1;
        a2=_a2;

    }
    //抽象基类：如果包含纯虚函数，此类是抽象基类   由于抽象类不能实例化对象，只能做基类使用->（抽象基类）
    //纯虚函数：函数声明时=0；
    virtual void print()=0;//纯虚函数：说明这个类是一个抽象基类
    //子类中必须实现纯虚函数，如果没有实现*、（子类也是一个抽象类）
    virtual void move(int _a1,int _a2)=0;
};
class B:public A{
private:
public:
    B(int _a1,int _a2):A(_a1,_a2){

    }
    void print(){
        cout<<"virtual"<<endl;
        cout<<a1<<","<<a2<<endl;
    }
    void move(int _a1,int _a2){
        a1=_a1+2;
        a2=_a2+5;
    }

};

int main(){
   // A a(3,4);//A是一个抽象类，不能创建对象
    B b(10,20);//若在B类中没有重写基类的纯虚函数，则B类也是抽象类，不能创建对象
    b.print();
    return 0;
}