[C++] 多态性和虚函数

1.为何须要virtual
按照Java的思惟方式，在有了继承和向上类型转换(upcasting)以后，就能够实现多态性了。可是在C++中彷佛并不能orz。考虑这种状况：

#include<iostream>
using std::cout;
using std::endl;
class A{
public:
  void f() const{
    cout<<"class A's function"<<endl;
  }
};
class B : public A{
public:
  void f() const{
    cout<<"class B's function"<<endl;
  }
};

int main(){
  B b;
  A *ptr_a = &b;
  A &ref_a = b;
  ptr_a->f();//print: class A's function
  ref_a.f();//print: Class A's function
}

在使用基类指针或引用调用一个派生类对象的函数时，咱们发现程序仍然在调用基类的函数，要想解决这种状况，就要引入virtual关键字，将上面代码里的class A修改以下，main中的输出就变成类B中f()的输出了。

class A{
public:
  virtual void f() const{
    cout<<"class A's function"<<endl;
  }
};

那么为何Java不须要呢？由于virtual关键字实现功能的同时，会增长该类一些操做的时间和空间占用，C++将这部分占用的优化决定权交给了程序员，以实现可能的效率提升；而Java内置了virtual的机制，没有提升效率的选择，可是简化了编程。(关于virtual的具体机制，建议参考Thinking in C++)

有两点须要注意的：
第1、当使用基类指针指向派生类时，没法经过基类指针直接调用派生类中增长的函数（基类中没有同名虚函数），除非将基类指针强制类型转换为派生类指针。
第2、只能经过基类指针或者引用来调用派生类对象，若是咱们将一个派生类对象经过值传递的方式传递给基类对象，这个对象被真的切成一个基类对象，而不具备任何派生类的内容。

2.纯虚函数和抽象类
在类设计时，经常但愿基类仅仅做为派生类的一个接口，被继承实现，而不会去建立基类对象，这时，能够在基类中定义纯虚函数，使其成为一个抽象类。定义纯虚函数语法是在一个虚函数声名的基础上，加上=0。例如：virtual void f() = 0;
注意：当继承一个抽象类时，必须实现其全部的纯虚函数，不然继承出的类也是一个抽象类。

通常状况下，在基类中咱们不会对纯虚函数进行实现，可是C++提供了实现纯虚函数的机制，这种方法可让咱们定义一段公共代码，使派生类能够公用。

class A{
public:
  virtual void do() = 0; 
};
/*
*纯虚函数不能做为inline函数实现，要放在类外！
*/
void A::do(){
  //一些公共代码
}
class B : public A{
public:
  void do() {
    A::do();
    //其余代码
  }
};

3.构造函数与虚函数
如上文所说，定义一个虚函数时，须要作一些额外的工做，完成这些工做的代码其实被秘密插入到类构造函数的开头部分。那么就有一个问题，若是咱们在构造函数中调用虚函数会发生什么现象？答案是，会调用这个虚函数的本地版本，即虚函数机制在构造函数中不工做。
另外，构造函数也不能被定义为虚函数。
4.虚析构函数与纯虚析构函数
构造函数不能被定义为虚函数，而析构函数能够，而且常常被定义为虚函数。

#include<iostream>
using namespace std;

class Base1{
public:
  ~Base1(){cout<<"~Base1()"<<endl;}
};
class Base2{
public:
  virtual ~Base2(){cout<<"~Base2()"<<endl;}
};
class Derived1 : public Base1{
public:
  ~Derived1(){cout<<"~Derived1()"<<endl;}
};
class Derived2 : public Base2{
public:
  ~Derived2(){cout<<"~Derived2()"<<endl;}
};

int main(){
  Base1* pd1 = new Derived1();
  Base2* pd2 = new Derived2();
  delete pd1;
  delete pd2;
}

上面代码的控制台输出：
~Base1()
~Derived2()
~Base2()
上面的代码暴露出在使用多态性时，不把析构函数定义成虚函数所带来的影响。这种错误不会马上使程序崩溃，可是它不知不觉中使内存泄漏。

纯虚析构函数的应用
在一些时候，咱们须要定义一个抽象类，可是恰好没有其余纯虚函数，这时候咱们不妨将析构函数定义为纯虚的，由于做为基类的析构函数原本就要求为虚函数，将其进一步定义为纯虚函数并没有太大不一样。惟一须要注意的是，定义纯虚析构函数时必须为其提供函数体，以下。

class A{
public:
  virtual ~A() = 0;
};
A::~A(){ }

class B:public A{
//不必定须要重定义析构函数，根据须要
}

还要注意一点，在析构函数中，虚机制也是不存在的，可经过下面的代码体会。

#include<iostream>
using namespace std;

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

int main(){
  Base * pb = new Derived();
  delete pb;
}

控制台输出为：~Derived()~Base()Base::f()