c++ 虚函数

在类的编程中，要能进行抽象编程，不随类的改动而改动。类机制必须解决这个问题。在c++中就是虚函数机制。基类与派生类的同名操作，只要标记上virtual，该操作便具有多态性。

一旦标记基类的函数为虚函数，便有连锁反应，后面继承的类中一切同类型同名成员函数都变成了虚函数。

仅仅对于对象的指针和引用的间接访问，才会发生多态现象。对于传值操作，引发了复制动作，已经将对象的性质做了肯定的转变，则不会多态了（多态是利用虚函数实现捆绑滞后，在编译时以一个不确定的指针待命，运行时才会指定真正的行为）。

用了虚函数的类，其对象空间比不用虚函数的类多了一个指针的空间。

面向对象的真意：
只有在加上virtual的成员函数之后，才被编译做之后处理，滞后的间接效应，解决了重要的多态问题，使得使用类的用户可以与以前基于对象的编程保持一致，进行抽象编程。

编译器看见虚函数调用，就要做滞后处理。由于间接访问比直接访问饶了一个弯，于是付出了时间代价和保存若干指针地址的空间代价。为了在使用类的编程中随时随地体现多态性，只要是继承结构，应尽量将成员函数设计成虚函数。

在一些讲究性能的小规模(如嵌入式)编程中，应不设虚函数。

虚函数的传播：
虚函数在继承层次结构中总会自动的从基类传播下去。子类中的同名函数(且同参)的virtual可以省去。

实例：

#include <iostream>
#include <cmath>
using namespace std;

class Shape{
protected:
    double xCoord,yCoord;
public:
    Shape(double x,double y):xCoord(x),yCoord(y){}
    virtual double area() const{return 0.0;}
};

class Circle:public Shape{
protected:
    double radius;
public:
    Circle(double x,double y,double r):Shape(x,y),radius(r){}
    double area()const{return 3.14*radius*radius;}
};

class Rectangle:public Shape{
protected:
    double x2Coord,y2Coord;
public:
    Rectangle(double x1,double y1,double x2,double y2)
    :Shape(x1,y1),x2Coord(x2),y2Coord(y2){}
    double area()const;
};

double Rectangle::area()const{
    return abs((xCoord-x2Coord)*(yCoord-y2Coord));
}

void fun(const Shape& sp){//绑定基类的引用才可以，普通传值只会破坏多态
    cout<<sp.area()<<"\n";
}

int main(){
    fun(Circle(2,5,4));
    fun(Rectangle(2,4,1,2));
}

只要在继承体系中设计了虚函数，则使用类体系的用户便可以将抽象进行到底了。

使用虚函数实现多态时，基类和子类的虚函数不能只是名字重载，而是其声明要一模一样。

实例：
下面的程序，在派生类中重载了基类的成员函数，尽管标记了virtual，但运行中起不到多态的效果。

#include <iostream>
using namespace std;

class Base{
public:
    virtual void fn(int x){
        cout<<"in base class,int x= "<<x<<"\n";
    }
};

class Sub:public Base{
public:
    virtual void fn(double x){
        cout<<"in sub class,double x= "<<x<<"\n";
    }
};

void test(Base& b){
    b.fn(2);
    b.fn(3.5);
}

int main(){
    test(Base());
    test(Sub());
}

运行结果：

in base class,int x=2
in base class,int x-3
in base class,int x=2
in base class,int x=3

因为函数参数不匹配才导致多态错误。

返回类型的例外：
函数重载时，对于两个相同参数描述却返回类型不同的函数，在调用中会发生编译器报错，原因是重载识别是基于不同的参数类型描述的。

函数覆盖，是同名同参数同返回类型的函数。

但在使用虚函数进行多态时，返回类型，允许不同（仅限返回类名对象指针），也认为是属于函数覆盖。

例子：

#include<iostream>
using namespace std;
class Base{
public:
    virtual Base* afn(){
        cout<<"in base class\n";
        return this;
    }
};

class Sub:public Base{
public:
    Sub* afn(){
        cout<<"in sub class\n";
        return this;
    }
};

void test(Base& x){
    Base* b;
    b=x.afn();
}

int main(){
    test(Base());
    test(Sub());
}

运行结果：

in base class
in sub class

关于虚函数的一些说明：
1、只有类的成员函数才能声明为虚函数
这是因为虚函数只适应于有继承关系的类对象，所以普通函数不能声明为虚函数。

2、静态成员函数不能是虚函数
因为静态成员函数不受对象的捆绑，即使形式上的捆绑，实际上也没有任何对象的信息，只有类的信息。
操作不受对象捆绑，也就失去了多态的条件。因为编译是在识别到对象的捆绑操作时开始之后捆绑的。

3、内联函数不能是虚函数
因为内联函数是不能在运行中动态的确定其位置的。即使虚函数在类的内部定义，编译时，仍将其看作是非内联的。

4、构造函数不能是虚函数
因为构造时，对象还未定型，只有在构造完成后，对象才会称为一个名副其实的对象。

5、析构函数可以是虚函数且通常声明为虚函数