8.2虚函数

类模板和虚函数，都是实现多态的重要方法。

类模板，锁定算法、步骤，偏重类型相同。

虚函数，偏重步骤不相同。

7.5.2虚基类

当在多条继承路径上有一个公共的基类,在这些路径中的某几条汇合处，这个公共的基类就会产生多个实例(或多个副本)，若只想保存这个基类的一个实例，可以将这个公共基类说明为虚基类。

在继承中产生歧义的原因有可能是继承类继承了基类多次，从而产生了多个拷贝，即不止一次的通过多个路径继承类在内存中创建了基类成员的多份拷贝。虚基类的基本原则是在内存中只有基类成员的一份拷贝。这样，通过把基类继承声明为虚拟的，就只能继承基类的一份拷贝，从而消除歧义。用virtual限定符把基类继承说明为虚拟的。

如果一个派生类从多个基类派生，而这些基类又有一个共同的基类，则在对该基类中声明的名字进行访问时，可能产生二义性。

如果在多条继承路径上有一个公共的基类，那么在继承路径的某处汇合点，这个公共基类就会在派生类的对象中产生多个基类子对象。

要使这个公共基类在派生类中只产生一个子对象，必须对这个基类声明为虚继承，使这个基类称为虚基类。

虚继承声明使用关键字virtual

1 没有声明虚基类

2 声明了虚基类

1 没有声明虚基类

//可以看到，创建一个ABobj的类，创建了两个obj基类

//1>main.cpp(60) : error C2385 : 对“num”的访问不明确

//1> main.cpp(60) : note : 可能是“num”(位于基“obj”中)

//1> main.cpp(60) : note : 也可能是“num”(位于基“obj”中)

#include <iostream>

class obj
{
public:
    int num;
    obj(int data) :num(data)//构造函数
    {
        std::cout << "obj create" << std::endl;
    }
    ~obj()//析构函数
    {
        std::cout << "obj delete" << std::endl;
    }
};

class Aobj :public obj
{
public:
    Aobj(int data) :obj(data)//构造函数
    {
        std::cout << "Aobj create" << std::endl;
    }
    ~Aobj()//析构函数
    {
        std::cout << "Aobj delete" << std::endl;
    }
};

class Bobj :public obj
{
public:
    Bobj(int data) :obj(data)//构造函数
    {
        std::cout << "Bobj create" << std::endl;
    }
    ~Bobj()//析构函数
    {
        std::cout << "Bobj delete" << std::endl;
    }
};

class ABobj :public Aobj, public Bobj
{
public:
    ABobj(int x, int y) :Aobj(x), Bobj(y)//构造函数
    {
        std::cout << "ABobj create" << std::endl;
    }
    ~ABobj()//析构函数
    {
        std::cout << "ABobj delete" << std::endl;
    }
};

void main()
{
    ABobj *p = new ABobj(10, 20);

    //std::cout << p->num;

    //1>main.cpp(60) : error C2385 : 对“num”的访问不明确
    //    1>  main.cpp(60) : note : 可能是“num”(位于基“obj”中)
    //    1>  main.cpp(60) : note : 也可能是“num”(位于基“obj”中)

    std::cout << p->Aobj::num << std::endl;//10
    std::cout << p->Bobj::num << std::endl;//20

    delete p;

    system("pause");
}

//没有声明虚基类
//可以看到，创建一个ABobj的类，创建了两个obj基类

//obj create
//Aobj create
//obj create
//Bobj create
//ABobj create
//10
//20
//ABobj delete
//Bobj delete
//obj delete
//Aobj delete
//obj delete
//请按任意键继续. . .

2 声明了虚基类

//可以看到，创建一个ABobj的类，只创建了一个obj基类

#include <iostream>

class obj
{
public:
    int num;
    obj(int data) :num(data)//构造函数
    {
        std::cout << "obj create" << std::endl;
    }
    ~obj()//析构函数
    {
        std::cout << "obj delete" << std::endl;
    }
};

class Aobj :virtual public obj//声明obj是虚基类
{
public:
    Aobj(int data) :obj(data)//构造函数
    {
        std::cout << "Aobj create" << std::endl;
    }
    ~Aobj()//析构函数
    {
        std::cout << "Aobj delete" << std::endl;
    }
};

class Bobj :virtual public obj//声明obj是虚基类
{
public:
    Bobj(int data) :obj(data)//构造函数
    {
        std::cout << "Bobj create" << std::endl;
    }
    ~Bobj()//析构函数
    {
        std::cout << "Bobj delete" << std::endl;
    }
};

class ABobj :public Aobj, public Bobj
{
public:
    ABobj(int x) :obj(x), Aobj(x), Bobj(x)//构造函数，直接初始化虚基类obj
    {
        std::cout << "ABobj create" << std::endl;
    }
    ~ABobj()//析构函数
    {
        std::cout << "ABobj delete" << std::endl;
    }
};

void main()
{
    ABobj *p = new ABobj(10);

    std::cout << p->num << std::endl;//10

    std::cout << p->Aobj::num << std::endl;//10
    std::cout << p->Bobj::num << std::endl;//10

    delete p;

    system("pause");
}

//声明了虚基类
//可以看到，创建一个ABobj的类，只创建了一个obj基类

//obj create
//Aobj create
//Bobj create
//ABobj create
//10
//10
//10
//ABobj delete
//Bobj delete
//Aobj delete
//obj delete
//请按任意键继续. . .

virtual

virtual

第8章 虚函数与多态性

多态性是指一个名字，多种语义；或界面相同，多种实现。

重载函数是多态性的一种简单形式。

虚函数允许函数调用与函数体的联系在运行时才进行，称为动态联编。

8.3 虚函数与动态联编

8.4 纯虚函数与抽象类

8.5 虚函数和多态性的应用

小结

 

8.3 虚函数与动态联编

虚函数一般起到接口作用。

冠以关键字virtual的成员函数称为虚函数。

实现运行时多态的关键首先是要说明虚函数，另外，必须用基类指针调用派生类的不同实现版本。

8.3.1虚函数和基类指针

基类指针虽然获取派生类对象地址，却只能访问派生类从基类继承的成员。

4 用派生类指针引用一个基类对象；

//static_cast用于一般的数据类型转换

zi *pzifu = static_cast<zi *>(new fu);

#include <iostream>

class fu
{
public:
    void name()
    {
        std::cout << "父类" << std::endl;
    }
};

class zi :public fu
{
public:
    void name()
    {
        std::cout << "子类" << std::endl;
    }
};

class sun :public zi
{
public:
    void name()
    {
        std::cout << "孙类" << std::endl;
    }
};

void main()
{
    fu *pfu = new fu;
    pfu->name();//父类

    zi *pzi = new zi;
    pzi->name();//子类

    sun *psun = new sun;
    psun->name();//孙类

    zi *pzifu = static_cast<zi *>(new fu);//4 用派生类指针引用一个基类对象
    pzifu->name();//子类

    sun *psunfu = static_cast<sun *>(new fu);//4 用派生类指针引用一个基类对象
    psunfu->name();//孙类
    
    system("pause");
}

3 用基类指针引用一个派生类对象；

((zi *)pfu)->name();//强制类型转换

#include <iostream>

class fu
{
public:
    void name()
    {
        std::cout << "父类" << "x=" << x << std::endl;
    }
    int x;
    fu(int a) :x(a)
    {

    }
};

class zi :public fu
{
public:
    void name()
    {
        std::cout << "子类" << "x=" << x << ",y=" << y << std::endl;
    }
    int y;
    zi(int a, int b) :fu(a), y(b)
    {

    }
};

class sun :public zi
{
public:
    void name()
    {
        std::cout << "孙类" << "x=" << x << ",y=" << y << ",z=" << z << std::endl;
    }
    int z;
    sun(int a, int b, int c) :zi(a, b), z(c)
    {

    }
};

void main()
{
    fu fu1(1);
    zi zi1(2, 3);
    sun sun1(4, 5, 6);

    fu *pfu = &fu1;
    pfu->name();//父类

    pfu = &zi1;//3 用基类指针引用一个派生类对象
    pfu->name();//父类

    pfu = &sun1;
    pfu->name();//父类

    ((zi *)pfu)->name();//强制类型转换，子类
    ((sun *)pfu)->name();//强制类型转换，孙类

    system("pause");
}

面试

虚函数实质上是函数指针，占4个字节(32位)，8个字节（64位）

#include <iostream>

class fu
{
public:
    virtual void name()//虚函数实质上是函数指针，占4个字节(32位)，8个字节（64位）
    {
        std::cout << "父类" << "x=" << x << std::endl;
    }
    int x;
    fu(int a) :x(a)
    {

    }
};

void main()
{
    std::cout << sizeof(fu) << std::endl;//8

    system("pause");
}

面试

单一继承

调用虚函数表

顺序：从上到下，如果是有继承，则调到基类，继续从上到下

#include <iostream>

class A
{
    virtual void g()//虚函数。跳过
    {
        std::cout << "A::g" << std::endl;
    }
private:
    virtual void f()//虚函数。第2
    {
        std::cout << "A::f" << std::endl;
    }
};
class B : public A
{
    void g()//实现了基类的虚函数,覆盖了基类的虚函数。第1
    {
        std::cout << "B::g" << std::endl;
    }
    virtual void h()//新的虚函数。第3
    {
        std::cout << "B::h" << std::endl;
    }
};

typedef void(*Fun)(void);

void main()
{

    std::cout << sizeof(A) << std::endl;//4，虚函数实质上是函数指针
    std::cout << sizeof(B) << std::endl;//4，虚函数实质上是函数指针

    B b;
    Fun pFun;

    for (int i = 0; i < 3; i++)//由于覆盖了基类的虚函数，因此有3个虚函数
    {
        pFun = (Fun)*((int*)* (int*)(&b) + i);
        //&b取b地址
        //32位的函数指针是4个字节，(int*)(&b)读取4个字节
        //(int*)* (int*)(&b)转换成指针

        pFun();
    }

    system("pause");
}

4
4
B::g
A::f
B::h
请按任意键继续. . .

调试->局部变量

面试

多重继承

调用虚函数表

#include <iostream>

class A
{
    virtual void g()//虚函数。跳过
    {
        std::cout << "A::g" << std::endl;
    }
private:
    virtual void f()//虚函数。第2
    {
        std::cout << "A::f" << std::endl;
    }
    virtual void j()//虚函数。第3
    {
        std::cout << "A::j" << std::endl;
    }
};

class H
{
    virtual void M()//虚函数。
    {
        std::cout << "H::M" << std::endl;
    }
};

class B : public A, public H
{
    void g()//实现了基类的虚函数,覆盖了基类的虚函数。第1
    {
        std::cout << "B::g" << std::endl;
    }
    virtual void o()//虚函数。第4
    {
        std::cout << "B::o" << std::endl;
    }
    virtual void h()//虚函数。第5
    {
        std::cout << "B::h" << std::endl;
    }
};

typedef void(*Fun)(void);

void main()
{
    std::cout << sizeof(A) << std::endl;//4
    std::cout << sizeof(H) << std::endl;//4
    std::cout << sizeof(B) << std::endl;//8，多重继承有2个虚函数表

    B b;
    Fun pFun;

    for (int i = 0; i < 5; i++)
    {
        pFun = (Fun)*((int*)* (int*)(&b) + i);

        pFun();
    }
    std::cout << "
";

    Fun pFun1 = (Fun)*((int *)*((int*)(&b) + 1));//基类H

    pFun1();
}

4
4
8
B::g
A::f
A::j
B::o
B::h
H::M
请按任意键继续. . .

//没有virtual，会一直调用基类的函数

//如果有virtual，会根据对象的类型调用不同的函数

#include <iostream>

//没有virtual，会一直调用基类的函数
//如果有virtual，会根据对象的类型调用不同的函数

class fu
{
public:
    virtual void name()//虚函数实质上是指针，占4个字节(32位)，8个字节（64位）
    {
        std::cout << "父类" << "x=" << x << std::endl;
    }
    int x;
    fu(int a) :x(a)
    {

    }
};

class zi :public fu
{
public:
    void name()
    {
        std::cout << "子类" << "x=" << x << ",y=" << y << std::endl;
    }
    int y;
    zi(int a, int b) :fu(a), y(b)
    {

    }
};

class sun :public zi
{
public:
    void name()
    {
        std::cout << "孙类" << "x=" << x << ",y=" << y << ",z=" << z << std::endl;
    }
    int z;
    sun(int a, int b, int c) :zi(a, b), z(c)
    {

    }
};

void main()
{
    fu fu1(1);
    zi zi1(2, 3);
    sun sun1(4, 5, 6);

    fu *pfu = &fu1;
    pfu->name();//父类

    pfu = &zi1;//3 用基类指针引用一个派生类对象
    pfu->name();//子类

    pfu = &sun1;
    pfu->name();//孙类

    system("pause");
}

注意：

一个虚函数，在派生类层界面相同的重载函数都保持虚特性。

虚函数必须是类的成员函数。

不能将友元说明为虚函数，但虚函数可以是另一个类的友元。

析构函数可以是虚函数，但构造函数不能是虚函数。

3 用基类指针引用一个派生类对象；

构造的时候将会调用基类的构造函数、派生类的构造函数，析构的时候，会调用基类的析构函数，但不会调用派生类的构造函数。

这样将会内存泄漏。

解决办法：使用虚析构函数。

#include <iostream>

using namespace std;

class A
{
public:
    A()//构造函数不可以是虚函数，如果是虚函数，那么将不会构造
    {
       std::cout<<"a create"<<std::endl;
    }
    ~A()
    {
        std::cout<<"a delete"<<std::endl;
    }
};

class B:public A
{
public:
    B()
    {
       std::cout<<"b create"<<std::endl;
    }
    ~B()
    {
        std::cout<<"b delete"<<std::endl;
    }
};

int main(int argc, char *argv[])
{
    cout << "Hello World!" << endl;

    A *p=new B;
    delete p;

    return 0;
}

输出结果：

a create

b create

a delete

8.3.2虚函数的重载特性

在派生类中重载基类的虚函数要求函数名、返回类型、参数个数、参数类型和顺序完全相同。

如果仅仅返回类型不同，C++认为是错误重载。

如果函数原型不同，仅函数名相同，丢失虚特性。

8.4 纯虚函数与抽象类

纯虚函数是一个在基类中说明的虚函数，在基类中没有定义，要求任何派生类都定义自己的版本。

纯虚函数为各派生类提供一个公共界面。

纯虚函数说明形式：

virtual 类型 函数名(参数表)=0;

一个具有纯虚函数的基类称为抽象类。

//有一个纯虚函数，都是抽象类，无法实例化

//抽象类不可以用于函数的参数以及返回值类型，但是抽象类指针可以用于函数的参数以及返回值类型

#include <iostream>

class base
{
public:
    virtual void run() = 0;//有一个纯虚函数，都是抽象类，无法实例化
    virtual ~base()
    {

    }
};

base *test(base *p)//抽象类不可以用于函数的参数以及返回值类型，但是抽象类指针可以用于函数的参数以及返回值类型
{
    base *pbase(nullptr);
    return pbase;
}

//抽象类无法实例化对象，但是可以实例化指针

//纯虚函数，抽象类与虚函数起到接口的作用

//用同一接口完成不同的功能

//纯虚函数完全就是为了接口的存在，有了纯虚函数的类无法实例化

//虚函数占4个字节，就是函数指针实现的

#include <iostream>

class base
{
public:
    virtual void run() = 0;//有一个纯虚函数，都是抽象类，无法实例化
    virtual ~base()
    {

    }
};

class boy :public base
{
public:
    void run()
    {
        std::cout << "男孩奔跑" << std::endl;
    }
};

class girl :public base
{
public:
    void run()
    {
        std::cout << "女孩奔跑" << std::endl;
    }
};

void main()
{
    //抽象类无法实例化对象，但是可以实例化指针
    //纯虚函数，抽象类与虚函数起到接口的作用
    //用同一接口完成不同的功能
    //纯虚函数完全就是为了接口的存在，有了纯虚函数的类无法实例化
    //虚函数占4个字节，就是函数指针实现的
    boy boy1;
    girl girl1;
    base *p(nullptr);//空指针

    p = &boy1;
    p->run();

    p = &girl1;
    p->run();

    system("pause");
}

使用QT，创建一个抽象类，并派生出多个类以分别实现Dialog，QLabel，QPushButton

#include "dialog.h"
#include <QApplication>

class basebase
{
public:
    virtual void show()=0;
    virtual void hide()=0;
};

class base:public basebase
{
public:
    virtual void resize(int x,int y)=0;
    virtual void move(int cx,int cy)=0;
};

class mydialog:public base//Dialog
{
public:
    Dialog w;
    void show()
    {
        w.show();
    }
    void hide()
    {
        w.hide();
    }
    void resize(int x,int y)
    {
        w.resize(x,y);
    }
    void move(int cx,int cy)
    {
        w.move(cx,cy);
    }
};

class mybutton:public base//QPushButton
{
public:
    QPushButton w;
    void show()
    {
        w.show();
    }
    void hide()
    {
        w.hide();
    }
    void resize(int x,int y)
    {
        w.resize(x,y);
    }
    void move(int cx,int cy)
    {
        w.move(cx,cy);
    }
};

class mylabel:public base//QLabel
{
public:
    QLabel w;
    void show()
    {
        w.show();
    }
    void hide()
    {
        w.hide();
    }
    void resize(int x,int y)
    {
        w.resize(x,y);
    }
    void move(int cx,int cy)
    {
        w.move(cx,cy);
    }
};

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    //Dialog w;
    //w.show();

    mydialog dialog1;
    mybutton button1;
    mylabel label1;
    base *pbase(nullptr);

    pbase=&dialog1;
    pbase->show();
    pbase->resize(100,200);

    pbase=&button1;
    pbase->show();
    pbase->resize(200,200);

    pbase=&label1;
    pbase->show();
    pbase->resize(300,200);

    return a.exec();
}

当编译系统编译含有虚函数的类时，将为它建立一个虚函数表，表中的每一个元素都指向一个虚函数的地址。

一个或者多个虚函数，或者有多个纯虚函数都占4个字节

一个指针存储了虚函数表的地址

8.5 虚函数和多态性的应用

虚函数和多态性使成员函数根据调用对象的类型产生不同的动作。

多态性特别适合于实现分层结构的软件系统，便于对问题抽象时定义共性，实现时定义区别。

小结

虚函数和多态性使软件设计易于扩充。

派生类重载基类接口相同的虚函数其虚特性不变。

如果代码关联在编译时确定，称为静态联编。代码在运行时关联称为动态联编。

基类指针可以指向派生类对象、基类拥有虚函数，是支持多态性的前提。

虚析构函数可以正确释放动态派生类对象的资源。

纯虚函数由派生类定义实现版本。

具有纯虚函数的类称为抽象类。抽象类只能作为基类，不能建立对象。抽象类指针使得派生的具体类对象具有多态操作能力。