C++多态深度解析

一.多态的概念

通过使用virtual关键字对多态进行支持，被virtual声明的函数被重写后具有多态特性，virtual声明的函数叫虚函数。

#include <iostream>
#include <string>
 
using namespace std;
 
class Parent
{
public:
    virtual void print() //使用virtual，变成虚函数（这个函数可能在子类被重写）
    {
        cout << "I'm Parent." << endl;
    }
};
 
class Child : public Parent
{
public:
    void print()  //由于继承关系，这里也是虚函数，只是可以省略不写
    {
        cout << "I'm Child." << endl;
    }
};
 
void how_to_print(Parent* p)
{
    p->print();     // 展现多态的行为
}
 
int main()
{
    Parent p;
    Child c;
    
    how_to_print(&p);    // Expected to print: I'm Parent.
    how_to_print(&c);    // Expected to print: I'm Child.
    
    return 0;
}

结果：

I'm Parent.
I'm Child.    

 子类中重写的函数将覆盖父类中的函数，虽然被重写覆盖了，但通过作用域分辨符（::）可以访问到父类中的函数。

二.虚函数与纯虚函数

纯虚函数和虚函数都是使用virtual关键字，只是纯虚函数在函数原型后面加上“=0”，纯虚函数没有实例化，虚函数有函数体，有实例化，定义纯虚函数是为了实现一个接口，起到一个规范的作用。

#include <iostream>
 
using namespace std;
 
class A{
public:
  virtual void f(const string& str)=0;
  virtual void e() {
    cout << "Base e() : " << endl;
  }
};
// 缺省实现，纯虚函数可以有函数体，但必须类的外部定义，如果子类不想实现，可以调用基类的
void A::f(const string& str) {
   cout << "A f()" << str << endl;
}
 
class B : public A{
public:
// 本质上还是重写了，只不过直接调用了基类的函数实现
  virtual void f(const string& str){
    cout << "Call A::f " << endl;
    A::f(str);
  } 
  void e(){
    cout << "B e()" << endl;
  }
};
 
int main()
{
  B b;
  b.f("hello world");
  b.e();
  A *a = new B();
  // 都是多态
  a->f("hello");
  a->e();
  return 0;
}

三.对象的内存布局

对象的内存布局包括两方面：成员变量的内存，指向虚函数表指针的内存，静态变量与成员函数是不占用对象内存的。

空类的大小为：1

#include <iostream>
using namespace std;
 
class NoMembers
{
};
 
int main()
{
    NoMembers n;  // Object of type NoMembers.
    cout << "The size of an object of empty class is: "
         << sizeof(n) << endl;
}

含有虚函数成员的类大小为4：含有虚函数的类需要维护一个虚函数表，有一个指向虚函数表的指针.

class Base {
 
public:
 
virtual void f() { cout << "Base::f" << endl; }
 
virtual void g() { cout << "Base::g" << endl; }
 
virtual void h() { cout << "Base::h" << endl; }
 
};

多继承下类的大小

#include<iostream>
using namespace std;
 
 
class A     
{     
};    
 
class B     
{  
    char ch;     
    virtual void func0()  {  }   
};   
 
class C    
{  
    char ch1;  
    char ch2;  
    virtual void func()  {  }    
    virtual void func1()  {  }   
};  
 
class D: public A, public C  
{     
    int d;     
    virtual void func()  {  }   
    virtual void func1()  {  }  
};     
class E: public B, public C  
{     
    int e;     
    virtual void func0()  {  }   
    virtual void func1()  {  }  
};  
 
int main(void)  
{  
    cout<<"A="<<sizeof(A)<<endl;  //1   
    cout<<"B="<<sizeof(B)<<endl;  //4+4=8        
    cout<<"C="<<sizeof(C)<<endl;  //4+4=8    
    cout<<"D="<<sizeof(D)<<endl;  //8+4=12   
    cout<<"E="<<sizeof(E)<<endl;  //8+4=12    
    return 0;  
}  

虚继承的情况

class A {
 
    int a;
 
};
 
class B:virtual public A{
 
    virtual void myfunB(){}
 
};
 
class C:virtual public A{
 
    virtual void myfunC(){}
 
};
 
class D:public B,public C{
 
    virtual void myfunD(){}
 
};

以上代码中sizeof(A)=4,，sizeof(B)=12，sizeof(C)=12，sizeof(D)=16。

B，C中由于是虚继承因此大小为int大小，加指向虚基类的指针的大小，加指向虚函数表指针的大小。

四.class退化成了struct，他们内存布局一样

#include <iostream>
#include <string>
 
using namespace std;
 
class A       //大小
{
    int i;    //4
    int j;    //4
    char c;   //1 + 3(补3)
    double d; //8
public:
    void print()
    {
        cout << "i = " << i << ", "
             << "j = " << j << ", "
             << "c = " << c << ", "
             << "d = " << d << endl;
    }
};
 
struct B       //大小
{
    int i;     //4
    int j;     //4
    char c;    //1 + 3(补3)
    double d;  //8
};
 
int main()
{
    A a;
    
    cout << "sizeof(A) = " << sizeof(A) << endl;    // 20 bytes
    cout << "sizeof(a) = " << sizeof(a) << endl;
    cout << "sizeof(B) = " << sizeof(B) << endl;    // 20 bytes
    
    a.print();
    //p指向了a的地址
    B* p = reinterpret_cast<B*>(&a);    //a不是整数。&a变成地址后进行类型转换
    /*
    reinterpret_cast强制类型转换 
    用于指针类型间的强制转换
       用于整数和指针类型间的强制转换(类指针也是指针)
    */
    
    p->i = 1;
    p->j = 2;
    p->c = 'c';
    p->d = 3;
    
    a.print();
    
    p->i = 100;
    p->j = 200;
    p->c = 'C';
    p->d = 3.14;
    
    a.print();
    
    return 0;
}

五.多继承方式会产生多个虚函数表

#include <iostream>
#include <string>
 
using namespace std;
 
class BaseA
{
public:
    virtual void funcA()
    {
        cout << "BaseA::funcA()" << endl;
    }
};
 
class BaseB
{
public:
    virtual void funcB()
    {
        cout << "BaseB::funcB()" << endl;
    }
};
 
class Derived : public BaseA, public BaseB
{
 
};
 
int main()
{
    Derived d;
    BaseA* pa = &d;    //pa->BaseA
    BaseB* pb = &d;    //pb->BaseB
    BaseB* pbe = (BaseB*)pa;    // oops!!指向了A的虚函数表（重点在这里）
    BaseB* pbc = dynamic_cast<BaseB*>(pa);    //指向了B的虚函数表
    
    cout << "sizeof(d) = " << sizeof(d) << endl; //8，两个指针，指向虚函数表
    
    cout << "Using pa to call funcA()..." << endl;
    
    pa->funcA();    //BaseA::funcA()
    
    cout << "Using pb to call funcB()..." << endl;
    
    pb->funcB();    //BaseB::funcB()
    
    cout << "Using pbc to call funcB()..." << endl;
    
    pbc->funcB();   //BaseB::funcB()
    
    cout << endl;
    
    cout << "pa = " << pa << endl;    //假设：A
    cout << "pb = " << pb << endl;    //假设：B
    cout << "pbe = " << pbe << endl;    
    cout << "pbc = " << pbc << endl;
    
    return 0;
}

结果：

sizeof(d) = 8
Using pa to call funcA()...
BaseA::funcA()
Using pb to call funcB()...
BaseB::funcB()
Using pbc to call funcB()...
BaseB::funcB()
 
pa = 0xbf9d2558
pb = 0xbf9d255c
pbe = 0xbf9d2558
pbc = 0xbf9d255c

强制转换后（Base* pbb = (Base*)pa），pbb是BaseB类型，应该指向vptr2的虚函数表，但却指向了vptr1的虚函数表 。

这时需要进行强制类型转换时，C++中推荐使用新式类型转换关键字(dynamic_cast)！！，BaseB* pbc = dynamic_cast<BaseB*>(pa)，指向了B的虚函数表。