C++学习笔记 —— 虚函数

作者: Leung_ManWah | 来源:发表于2018-09-19 14:44 被阅读7次

一、虚函数实现多态

1.1 多态公有继承

假如希望同一个方法在派生类和基类中的行为是不同的，即同一个方法的行为随上下文而异，这种行为称为多台——具有多种形态。

有两种重要的机制可用于实现多太公有继承：

在派生类中重新定义基类的方法。
使用虚方法。

注意：如果要在派生类中重新定义基类的方法，通常应将基类方法声明为虚的。这样程序将根据对象类型而不是引用或指针的类型来选择方法版本。为基类声明一个虚析构函数也是一种惯例。

现有父类Brass和派生类BrassPlus

class Brass
{
private:
    ...
public:
    Brass(const std::string & s = "Nullbody", long an = -1, double bal = 0.0);
    ...
    virtual void ViewAcct() const; 
    ...
};
// 继承父类Brass
class BrassPlus : public Brass
{
private:
    ...
public:
    BrassPlus(const std::string & s = "Nullbody", long an = -1, double bal = 0.0, double ml =500, double r = 0.11125);
    ...
    virtual void ViewAcct() const;
    ... 
};

1.2 通过对象调用

由对象确定使用哪一种方法。

Brass dom("Dominic Banker", 11224, 4183.45);
BrassPlus dot("Dorothy Banker", 12118, 2592.00);
dom.ViewAcct();  // 调用Brass::ViewAcct()
dot.ViewAcct();  // 调用BrassPlus::ViewAcct()

1.3 通过引用或指针调用

如果方法是通过引用或指针而不是对象调用的，它将确定使用哪一种方法。

1.3.1 使用关键字virtual

如果使用了virtual，程序将根据引用或指针指向的对象的类型来选择方法。
引用的类型为Brass，但b2_ref引用的是一个BrassPlus对象，所以使用的是BrassPlus::ViewAcct()。使用Brass指针代替引用时，行为将与此类似。

类方法：virtual void ViewAcct() const;

Brass dom("Dominic Banker", 11224, 4183.45);
BrassPlus dot("Dorothy Banker", 12118, 2592.00);
Brass & b1_ref =dom;
Brass & b2_ref =dot;
b1_ref.ViewAcct();  // 调用Brass::ViewAcct()
b2_ref.ViewAcct();  // 调用BrassPlus::ViewAcct()

1.3.2 没有使用关键字virtual

如果没有使用关键字virtual，程序将根据引用类型或指针类型选择方法。
引用变量的类型为Brass，所以选择了Brass::ViewAcct()。使用Brass指针代替引用时，行为将与此类似。

类方法：void ViewAcct() const;

Brass dom("Dominic Banker", 11224, 4183.45);
BrassPlus dot("Dorothy Banker", 12118, 2592.00);
Brass & b1_ref =dom;
Brass & b2_ref =dot;
b1_ref.ViewAcct();  // 调用Brass::ViewAcct()
b2_ref.ViewAcct();  // 调用Brass::ViewAcct()

1.4 实现多态性

假设要同时管理Brass和BrassPlus账户，如果能使用同一个数组来保存Brass和BrassPlus对象，将很有帮助，但这是不可能的。数组中所有元素的类型必须相同，而Brass和BrassPlus是不同的类型。

然而，可以创建指向Brass的指针数组。这样，每个元素的类型都相同，但由于使用的是公有继承模型，因此Brass指针既可以指向Brass对象，也可以指向BrassPlus对象。因此，可以使用一个数组来表示多种类型的对象。这就是多态性。

...
...

int main()
{
    ...
    Brass * p_clients[4];
    for (int i = 0; i < 4; i++)
    {
        while (cin >> kind && (kind != '1' && kind != '2'))
            cout << "Enter either 1 or 2: ";
        if (kind == '1')
            p_clients[i] = new Brass(temp, tempnum, tempbal);
        else
        {
            ...
            p_clients[i] = new BrassPlus(temp, tempnum, tempbal, tmax, trate);
        }
        ...
    }
    ...
    for (int i = 0; i < 4; i++)
    {
         p_clients[i]->ViewAcct();
    }
}

如果数组成员指向的是Brass对象，则调用Brass::ViewAcct();如果指向的是BrassPlus对象，则调用BrassPlus::ViewAcct()。如果Brass::ViewAcct();未被声明为虚的，则在任何情况下都将调用Brass::ViewAcct()。

二、虚函数实现动态联编

2.1 动态联编

如上面程序所示，如果使用哪一个函数是不能在编译时确定的，因为编译器不知道用户将选择哪种类型的对象。所以，编译器必须生成能够在程序运行时选择正确的虚方法的代码，这被称为动态联编（dynamic binding）。

2.2 向上强制转换

通常，C++不允许将一种类型的地址赋给另一种类型的指针，也不允许一种类型的引用指向另一种类型：

double x = 2.5;
int * pi = &x;  // 不允许，不匹配的指针类型
long & rl = x;  // 不允许，不匹配的引用类型

然而，指向基类的引用或指针可以引用派生类对象，而不必进行显式类型转换。如下：

BrassPlus dilly("Annie Dill", 493222, 2000);
Brass * pb = &dilly;  // ok
Brass & rb = dilly;   // ok

将派生类引用或指针转换为基类引用或指针被称为向上强制转换（upcasting），这使公有继承不需要进行显式类型转换。该规则是is-a关系的一部分。BrassPlus对象都是Brass对象，因为它继承了Brass对象所有的数据成员和成员函数。所以，可以对Brass对象执行的操作，都适用于BrassPlus对象。

2.3 向下强制转换

相反的过程，将基类指针或者引用转换为派生类指针或引用——称为向下强制转换（downcasting）。如果不使用显式类型转换，则向下强制转换是不允许的。原因是is-a关系通常是不可逆的。

2.4 虚成员函数和动态联编

对于使用基类引用或指针作为参数的函数调用，将进行向上转换。假定以下每个函数都调用虚方法ViewAcct():

void fr(Brass & rb);    // uses rb.ViewAcct()
void fb(Brass * pb);    // uses pb->ViewAcct()
void fv(Brass b);       // uses b.ViewAcct()
int main()
{
    Brass b("Billy Bee", 123422, 10000.0);
    BrassPlus bp("Betty Beep", 232313, 12345.0);
    fr(b);    // uses Brass::ViewAcct()
    fr(bp);   // uses BrassPlus::ViewAcct()
    fp(b);    // uses Brass::ViewAcct()
    fp(bp);   // uses BrassPlus::ViewAcct()
    fv(b);    // uses Brass::ViewAcct()
    fv(bp);   // uses Brass::ViewAcct()
    ...
}

按值传递导致只将BrassPlus对象的Brass部分传递给函数fv()。但随引用和指针发生的隐式向上转换导致函数fr()和fp()分别为Brass对象和BrassPlus对象使用Brass::ViewAcct()和BrassPlus::ViewAcct()。

三、使用虚函数代价

使用虚函数时，在内存和执行速度方面有一定的成本，包括：

每个对象都将增大，增大量为存储地址的空间
（给每个对象添加一个隐藏成员，隐藏成员中保存了一个指向函数地址数组的指针）；
对于每个类，编译器都创建一个虚函数地址表（数组）
（上述隐藏的指针成员指向虚函数表）；
对于每个函数调用，都需要执行一项额外的操作，即到表中查找地址。

四、有关虚函数注意事项

要点：

在基类方法的声明中使用关键字virtual可使该方法在基类以及所有的派生类（包括从派生类派生出来的类）中是虚的。
如果使用指向对象的引用或指针来调用虚方法，程序将使用为对象类型定义的方法，而不使用为引用或指针类型定义的方法。这称为动态联编或晚期联编。这种行为非常重要，因为这样基类指针或引用可以指向派生类对象。
如果定义的类将被用作基类，则应将那些要在派生类中重新定义的类方法声明为虚的。

4.1 构造函数

构造函数不能是虚函数。创建派生类对象时，将调用派生类的构造函数，而不是基类的构造函数。然后，派生类的构造函数将使用基类的一个构造函数，这种顺序不同于继承机制。因此，派生类不继承基类的构造函数，所以将类构造函数声明为虚的没什么意义。

4.2 析构函数

析构函数应当是虚函数，除非类不用做基类。例如，假设Employee是基类，Singer是派生类，并添加一个char *成员，该成员指向由new分配的内存。当Singer对象过期时，必须调用~Singer()析构函数来释放内存。

Employee * pe = new Singer;  // 向上转换
...
delete pe;  // 此时调用~Employee()还是~Singer()？

如果使用默认的静态联编，delete语句将调用~Employee()析构函数。这将释放由Singer对象中的Employee部分指向的内存，但不会释放新的类成员指向的内存。

但如果析构函数是虚的，则将先调用~Singer()析构函数释放由Singer组件指向的内存，然后调用~Employee()析构函数来释放由Employee组件指向的内存。

因此，使用虚析构函数可以确保正确的析构函数序列被调用。

通常应给基类提供一个虚析构函数，即使它并不需要析构函数。

virtual ~BaseClass() { }

4.3 友元

友元不能是虚函数，因为友元不是类成员，而只有成员才能是虚函数。如果由于这个原因引起了设计问题，可以通过让友元函数使用虚成员函数来解决。

4.4 没有重新定义

如果派生类没有重新定义函数，将使用该函数的基类版本。如果派生类位于派生链中，则将使用最新的虚函数版本，例外的情况是基类版本时隐藏的。

4.5 重新定义将隐藏方法

重新定义继承的方法并不是重载。如果重新定义派生类中的函数，将不只是使用相同的函数参数列表覆盖基类声明，无论参数列表是否相同，该操作将隐藏所有的同名基类方法。

class Dwelling
{
public:
    virtual void showperks(int a) const;
    ...
};
class Hovel : public Dwelling
{
public:
    virtual void showperks() const;
    ...
};

Hovel trump;
trump.showperks();    // 可用
trump.showperks(5);   // 被隐藏不可用

这引出两条经验规则：
第一，如果重新定义继承的方法，应确保与原来的原型完全相同，但如果返回类型是基类引用或指针，则可用修改为指向派生类的引用或指针。这种特性被称为返回类型协变（covariance of return type），因为允许返回类型随类型的变化而变化：

class Dwelling
{
public:
// 基类方法
    virtual Dwelling & build(int n);
    ...
};
class Hovel : public Dwelling
{
public:
// a derived method with a covariant return type
     virtual Hovel & build(int n);    // same function signature
    ...
};

注意，这种例外只适用于返回值，而不适用于参数。

第二，如果基类声明被重载了，则应在派生类中重新定义所有的基类版本。

class Dwelling
{
public:
// 三个重载的showperks()函数
    virtual void showperks(int a) const;
    virtual void showperks(double b) const;
    virtual void showperks() const;
    ...
};
class Hovel : public Dwelling
{
public:
// 三个重新定义的showperks()函数
    virtual void showperks(int a) const;
    virtual void showperks(double b) const;
    virtual void showperks() const;    
    ...
};

如果只重新定义一个版本，则另外两个版本将被隐藏，派生类对象将无法使用它们。
注意，如果不需要修改，则新定义可只调用基类版本：

void Hovel::showperks() const {Dwelling::showperks();}

• 由 Leung 写于 2018 年 9 月 19 日

• 参考：C++ Primer Plus(第6版)