虚函数和多态

虚函数和多态

成员函数重写

子类继承了父类的所有成员函数，但是父类的成员函数不一定适合子类，子类可以重载或者重写（覆盖）父类的成员函数。

重载我们在之前的章节中已有介绍，即函数名相同，参数不同。
重写（覆盖）的意思是函数名和参数表完全一样，即函数的原型完全一样。

比如，void Human::introduce()函数的功能是输出人类的各成员变量的值。但是它并不合适Student对象，因为该函数没有输出Student类增加的年级成员变量grade的值。因此Student类可以新增一个更适合自己的版本，即重写（覆盖）该函数。

class Student : public Human
{
     public:
         void set_grade(int g){ grade = g; }
         int get_grade(){ return grade; }

         int grade;    

         void introduce();  // 新增introduce成员函数
};

void Student::introduce()
{
    // 与Human::introduce()函数实现相同的功能
    cout << "大家好，我是" << name << endl;
    if(is_male){
         cout << "男性" << endl;
    }else{
         cout << "女性" << endl;
    }
    cout << age << "岁" << endl;
    if(id.length() == 0){            
        cout << "身份证号未知" << endl;
    }else{
        cout << "身份证号:" << id << endl;
    }  
    // 新增grade成员的输出
    cout << "年级：" << grade << endl;
}

注意，与重载不同，重写（覆盖）只能发生在继承关系中。单独的一个类中的两个成员函数，或者类外部的两个函数是不能有相同的函数原型的。

class foo
{
public:
    void member(){};
    void member(){}; // 错误，一个类中不能出现原型完全一样的成员函数
};

void fun(int x){}
void fun(int x){}  // 错误，不能出现原型完全一样的函数

重写（覆盖）的意义在于子类可以增加一些成员函数，这些成员函数与父类的成员函数有相同的接口（函数原型），不同的实现。使它们更适合子类。换句话说即成员函数功能的细化。

重写（覆盖）的意义在于子类的”新版本“的成员函数优化了/细化了父类的一些”老版本“成员函数。

注意，父类的”老版本“的被重写的函数也被子类继承了，在子类中存在”老版本“和”新版本“的两种版本。在子类中要使用”老版本“的函数需要使用范围运算符::。否则，默认是”新版本“的。即重写和重载一样，在子类中都会自动隐藏父类的版本的函数。

下面是void Student::introduce()另一种正确的写法。

void Student::introduce()
{
    // 与Human::introduce()函数实现相同的功能，因此可以调用它
    Human::introduce();  
    // 新增grade成员的输出
    cout << "年级：" << grade << endl;
}

而下面的void Student::introduce()的实现会造成void Student::introduce()递归调用。

void Student::introduce()
{
    introduce();  // 错误，调用了Student::introduce自己，形成了递归调用，函数无法结束
    // 新增grade成员的输出
    cout << "年级：" << grade << endl;
}

继承遇到函数重写

前面说过，继承反映的是子类与父类之间“是一个”的关系，比如说对象赋值：

Human p;
Student s;
s.init("周润发", true, 30, "123456", 1);
p = s; // 把Student类对象s中包含的Human部分的各成员的值赋给p的各成员

再比如说，指针操作

Human *p_human = NULL;
Student s;
s.init("周润发", true, 30, "123456", 1);
p_human = &s;
p_human->introduce();

图

因为，定义p_human时指定它的类型是Human *，因此它认为自己指向的是Human对象。于是，p_human->introduce()调用的是void Human::introduce()方法。

不过，等等，这里我们是不是忽略了什么。

显然，p_human实际上指向的是Student类对象s，而Student重写了introduce方法，为什么p_human->introduce()调用的不能是”新版本“的introduce呢，它更适合Student对象啊。

在这种场景下，要想p_human->introduce()调用的是”新版本“的void Student::introduce()，那么introduce必须是虚函数。

虚函数和多态的含义

如果想在父类中定义一个成员函数留待子类中进行细化，我们必须在它前面加关键字virtual ，以便可以使用指针对指向相应的对象进行操作。

class Human
{
    public:
        void init(string n, int a, bool m, string i){
            name = n;
            age = a;
            is_male = m;
            id = i;
        }
        virtual void introduce();  // 虚函数
    private:
        string name;
        int age;
        bool is_male;
        string id;
};

void Human::introduce()
{
   cout << "大家好，我是" << name << endl;
    if(is_male){
         cout << "男性" << endl;
    }else{
         cout << "女性" << endl;
    }
    cout << age << "岁" << endl;
    if(id.length() == 0){            
        cout << "身份证号未知" << endl;
    }else{
        cout << "身份证号:" << id << endl;
    }  
}

class Student : public Human
{
    public:
        void init(string n, int a, bool m, string i, int g){
            Human::init(n, a, m, i);
            grade = g;
        }
        void introduce();
    private:
        int grade;  // 年级
};

void Student::introduce()
{
    Human::introduce();
    cout << "年级：" << grade << endl;
}

class Soldier : public Human
{
    public:
        void init(string n, int a, bool m, string i, string r){
            Human::init(n, a, m, i);
            rank = r;
        }
        void introduce();
    private:
        string rank;  // 军衔
};

void Soldier::introduce()
{
    Human::introduce();
    cout << "军衔：" << rank << endl;
}

int main()
{
    Human *p_human = NULL;

    Student s;
    s.init("周润发", true, 30, "12345", 1);
    Soldier s2;
    s2.init("刘伯承", true, 30, "23456", "元帅");

    p_human = &s;
    p_human->introduce();

    p_human = &s2;
    p_human->introduce();

    system("pause");

    return 0;
}

父类成员函数是虚函数，那么通过父类指针来调用，调用的版本由指针指向的对象来决定。这就体现了多态的含义。即一种接口，多种实现。

• 一种调用形式：p_human->introduce()
• 多种调用结果：实际被调用的可能是下面三个版本的introduce之一
  void Human::introduce()
  void Student::introduce()
  void Soldier::introduce()

大家可以去掉Human类中的virtual关键字，对比一下程序运行结果。

多态的应用

多态的作用

多态有什么作用呢？它帮助我们达到“软件复用”。

那在程序里，可能编写了很多处理Human类的代码，比如下面的函数，

...  // Human、Student、Soldier类的定义

void introduce_triple(Human *p)
{
    int i;
    for(i = 0; i < 3; i++){
        p->introduce();
    }
}

会让Human的进行3遍自我介绍。

那这个函数能否处理学生对象呢，即当p指向学生对象，p->introduce();是否可以调用学生类的introduce。在introduce函数是虚函数的情况下是可以的。

int main()
{
    Student s;
    s.init("周润发", true, 30, "12345", 1);
    Soldier s2;
    s2.init("刘伯承", true, 30, "23456", "元帅");

    introduce_triple(&s);

    introduce_triple(&s2);

    system("pause");

    return 0;    
}

举一个生活中的例子，TCL出了某款型号的彩电比如“栩栩如生”系列第一代产品，还有附带的遥控器可以来遥控电视。随后，后续又推出了该系列第二代、第三代产品。这时，大家可能会想，控制第一代的遥控器也可以控制它们就好了。如果可以，那遥控器就可以复用了。

什么时候父类成员函数加virtual关键字

什么时候需要将父类的成员函数修饰为虚函数，即加virtual关键字呢？就看这个函数是否是适应于子类的，

如果是成员函数适合子类的就不需要加virtual关键字。

如果子类可能会细化这个函数，那就需要在父类中加virtual关键字。

比如void Human::set_age(int age)和int Human::get_age()这两个函数是用来设置和读取年龄的。显然，Human类的子类不需要重写这个函数。那么这两个函数就不需要设置为虚函数。

还支持引用类型

多态必须通过父类指针调用才可以起作用，或者引用也可以，如下面的代码

...  // Human、Student、Soldier类的定义

void introduce_triple(Human &p)  // 父类的引用
{  
    int i;
    for(i = 0; i < 3; i++){
        p.introduce();
    }
}

int main()
{
    Student s;
    s.init("周润发", true, 30, "12345", 1);
    Soldier s2;
    s2.init("刘伯承", true, 30, "23456", "元帅");

    introduce_triple(s);

    introduce_triple(s2);

    system("pause");

    return 0;    
}

父类类型本身没有多态效果

如果不是指针和引用，而是父类类型，那么最终调用的是父类的版本，没有多态的效果。如下面代码：

...  // Human、Student、Soldier类的定义

void introduce_triple(Human p)  // 父类类型本身
{ 
    int i;
    for(i = 0; i < 3; i++){
        p.introduce();
    }
}

int main()
{
    Student s;
    s.init("周润发", true, 30, "12345", 1);
    Soldier s2;
    s2.init("刘伯承", true, 30, "23456", "元帅");

    introduce_triple(s);

    introduce_triple(s2);

    system("pause");

    return 0;    
}

抽象基类和纯虚函数

shape类的例子

语法细节

虚函数特性是被继承的，子类重写虚函数，在类的定义里可加virtual关键字也可不加。当然加上更明显的说明此函数是虚函数。

...

class Student : public Human
{
    public:
        void init(string n, int a, bool m, string i, int g){
            Human::init(n, a, m, i);
            grade = g;
        }
        virtual void introduce(); // 正确，也可以不加virtual关键字
    private:
        int grade;  // 年级
};

类定义中指出是某个成员函数是虚函数，如果该函数的实现写在类定义外边，不能加virtual关键字了。

virtual void Student::introduce() // 错误，不能在这里加virtual关键字
{
    Human::introduce();
    cout << "年级：" << grade << endl;
}

其它参考

多态介绍可参考4.4 多态 (Polymorphism)