C++学习一多态

---

一、虚函数

1. 在类的定义中，前面有 virtual 关键字的成员函数就是虚函数。

class base {
virtual int get() ;
};
int base::get() 
{ }

2. virtual 关键字只用在类定义里的函数声明中，写函数体时不用。

二、多态

1.表现形式一

1. 派生类的指针可以赋给基类指针。
2. 通过基类指针调用基类和派生类中的同名虚函数时:
   （1）若该指针指向一个基类的对象，那么被调用是
   基类的虚函数；
   （2）若该指针指向一个派生类的对象，那么被调用的是派生类的虚函数。
   这种机制就叫做“多态”。

class CBase {
    public:
        virtual void SomeVirtualFunction() {
            cout << "farther" << endl;
        }
};
class CDerived:public CBase {
    public :
        virtual void SomeVirtualFunction() {
            cout << "child" << endl;
    }
};
int main() {
    CDerived ODerived;
    CBase * p = & ODerived;
    p -> SomeVirtualFunction(); //调用哪个虚函数取决于p指向哪种类型的对象
    return 0;
}

2.表现形式二

1. 派生类的对象可以赋给基类引用
2. 通过基类引用调用基类和派生类中的同名虚函数时:
   （1）若该引用引用的是一个基类的对象，那么被调用是基类的虚函数；
   （2）若该引用引用的是一个派生类的对象，那么被调用的是派生类的虚函数。
   这种机制也叫做“多态”。

class CBase {
    public:
        virtual void SomeVirtualFunction() {
            cout << "farther" << endl;
        }
};
class CDerived:public CBase {
    public :
        virtual void SomeVirtualFunction() {
            cout << "child" << endl;
    }
};
int main() {
    CDerived ODerived;
    CBase & r = ODerived;
    r.SomeVirtualFunction(); //调用哪个虚函数取决于r引用哪种类型的对象

    CBase c;
    c.SomeVirtualFunction();
    return 0;
}

3.多态的作用

在面向对象的程序设计中使用多态，能够增强程序的可扩充性，即程序需要修改或增加功能的时候，需要改动和增加的代码较少。

三、构造函数和析构函数中调用虚函数

在构造函数和析构函数中调用虚函数，不是多态。编译时即可确定，调用的函数是自己的类或基类中定义的函数，不会等到运行时才决定调用自己的还是派生类的函数。
派生类中和基类中虚函数同名同参数表的函数，不加virtual也自动成为虚函数
在非构造函数，非析构函数的成员函数中调用虚函数，是多态.

class myclass {
    public:
        virtual void hello() { cout << "hello from myclass" << endl; };
        virtual void bye() { cout << "bye from myclass" << endl; }
};

class son : public myclass {
    public:
        void hello() { cout << "hello from son" << endl; };
        son() { hello(); };
        ~son() { bye(); };
};

class grandson : public son {
    public:
        void hello() { cout << "hello from grandson" << endl; };
        void bye() { cout << "bye from grandson" << endl; }
        grandson() { cout << "constructing grandson" << endl; };
        ~grandson() { cout << "destructing grandson" << endl; };
};

int main() {
    grandson gson;      //从上到下依次调用初始化构造函数，只有son有，所以先调用son构造函数，
    // 在调用grandson构造函数，所以输出：hello from son  constructing grandson
    son *pson;
    pson = &gson;  //父类指针指向子类对象
    pson->hello(); //多态     指针指向子类，打印grandson的hello   hello from grandson
    //调用析构函数，从子类一直调用到父类   destructing grandson   bye from myclass
    return 0;
}

四、多态的实现原理

1.虚函数表

1. 每一个有虚函数的类（或有虚函数的类的派生类）都有一个虚函数表，该类的任何对象中都放着虚函数表的指针。虚函数表中列出了该类的虚函数地址。多出来的4个字节就是用来放虚函数表的地址的。
2. 多态的函数调用语句被编译成一系列根据基类指针所指向的（或基类引用所引用的）对象中存放的虚函数表的地址，在虚函数表中查找虚函数地址，并调用虚函数的指令。

五、虚析构函数

1. 通过基类的指针删除派生类对象时，通常情况下只调用基类的析构函数
   但是，删除一个派生类的对象时，应该先调用派生类的析构函数，然后调用基类的析构函数。
2. 解决办法：把基类的析构函数声明为virtual
   派生类的析构函数可以virtual不进行声明
   通过基类的指针删除派生类对象时，首先调用派生类的析构函数，然后调用基类的析构函数
3. 一般来说，一个类如果定义了虚函数，则应该将析构函数也定义成虚函数。或者，一个类打算作为基类使用，也应该将析构函数定义成虚函数。
4. 注意：不允许以虚函数作为构造函数

class son{
    public:
        virtual ~son() {cout<<"bye from son"<<endl;};
};
class grandson:public son{
    public:
        ~grandson(){cout<<"bye from grandson"<<endl;};
};
int main() {
    son *pson;
    pson= new grandson();
    delete pson;
    return 0;
}
输出： 
bye from grandson
bye from son
执行grandson::~grandson()，引起执行son::~son()！！！

六、纯虚函数和抽象类

1.纯虚函数

没有函数体的虚函数

class A {
private: int a;
public:
    virtual void Print( ) = 0 ; //纯虚函数
    void fun() { cout << "fun"; }
};

2.抽象类

1. 包含纯虚函数的类叫抽象类
   抽象类只能作为基类来派生新类使用，不能创建独立的抽象类的对象
   抽象类的指针和引用可以指向由抽象类派生出来的类的对象

    A a ; // 错，A 是抽象类，不能创建对象
    A * pa ; // ok,可以定义抽象类的指针和引用
    pa = new A ; //错误, A 是抽象类，不能创建对象
   

2. 在抽象类的成员函数内可以调用纯虚函数，但是在构造函数或析构函数内部不能调用纯虚函数。

3. 如果一个类从抽象类派生而来，那么当且仅当它实现了基类中的所有纯虚函数，它才能成为非抽象类。

class A {
    public:
        virtual void f() = 0; //纯虚函数
        void g( ) { this->f( ) ; //ok
        }
        A( ){ //f( ); // 错误
        }
};
class B:public A{
    public:
        void f(){cout<<"B:f()"<<endl; }
};
int main(){
    B b;
    b.g();
    return 0;
}

---