C++：11---虚函数、虚函数表、多态、纯虚函数(抽象类、接口)

版权声明：本文章刊载的内容，多数为读者作者笔记，笔记内容来自于潭州教育提供的学习资源以及读者本人阅读的文章，特此声明！ https://blog.csdn.net/qq_41453285/article/details/84976409

 介绍虚函数之前，先举一个继承中的实例

class A
{
public:
    void show()const
    {cout<<"A";};
};
class B:public A //B继承于A
{
public:
    void show()const
    {cout<<"B";};
};
void printfShow(A const& data)
{
    data.show();
}
int main()
{
    A a;
    B b;
    printfShow(a); //打印A
    printfShow(b); //打印A
}

• 通过上面的实例可以告诉我们，在有继承的关系中，非虚函数的调用与对象无关，而是取决于类的类型，此处函数的参数类型为A，所有打印的永远是A里面的show()函数
• 下面举出一个相同的实例

class A
{
    int data;
public:
    A() { data = 1; }
    void show() { cout << "A:" << data; }
};
class B:public A
{
    int data;
public:
    B() { data = 2; }
    void show() { cout << "B:" << data; }
};

int main()
{
    A a, *pa;
    B b, *pb;
    pa = &a; pa->show();//打印1
    pb = &b; pb->show();//打印2

    pa = &b; pa->show();//打印1，因为pa的类型为A
    return 0;
}

/*==================================================*/
class A
{
    int data;
public:
    A(int data) { this->data = data; }
    void show() { cout << "A:" << data; }
};
class B:public A
{
    int data;
public:
    B():A(10) { data = 2; }
    void show() { cout << "B:" << data; }
};

int main()
{
    A a(1), *pa;
    B b, *pb;
    pa = &a; pa->show();//打印1
    pb = &b; pb->show();//打印2

    pa = &b; pa->show();//打印10，还是A中的show，因为B中对A进行了构造
    return 0;
}

一、虚函数

1.概念：

在函数前面加virtual，就是虚函数

 2.覆盖（重写）：基类的虚函数，如果派生类有相同的函数，则子类的方法覆盖了父类的方法(子类的函数前可省去virtual)

• 覆盖的要求：
• 只有成员函数才可定义为虚函数，友元/全局/static函数都不可以
• 函数名与参数列表相同
• 基类中函数前加virtual才可形成覆盖，否则为隐藏
• 函数在子类和父类中的访问权限可以不同

3.关键字

• virtual：用于虚函数前，加在父类的函数前，子类函数前不可加
• override：用于子类虚函数的参数列表后，用来说明此函数为虚函数(父类的虚函数不可使用)

二、虚函数表

1.概念：是一块连续的内存，所有虚函数的首地址都存放在虚函数表中，其大小为4字节

2.注意

• 只有类中有虚函数时，才有虚函数表
• 父子类之间的虚函数表是不同的地址，且虚函数表中的虚函数的首地址也不同

class A
{
public:
    virtual void run1(){};
    virtual void run2(){};
};
class A:public B
{
public:
    virtual void run1(){};
    virtual void run2(){};
};
int main()
{
    cout<<sizeof(A); //4
    cout<<sizeof(B); //4
}

3.通过指针访问虚函数表中的函数

原理：通过指针遍历虚函数表然后打印虚函数，虚函数都是按照顺序在内存中存储的

class A
{
public:
    virtual void run1(){cout<<"A1";};
    virtual void run2(){cout<<"A2";};
};

typedef void(*pFun)();
int main()//打印一个
{
    pFun pf = NULL;
    A a;
    pf = (pFun)*((int*)*(int *)&a);
    pf();//打印run1()函数
}
int main()//打印两个虚函数
{
    pFun pf = NULL;
    A a;
    for (int i = 0; i < 2; ++i)
    {
        pf = (pFun)*((int*)*(int *)&a+i);
        pf();
    }
}

三、多态

1.概念：在子类覆盖了父类函数的情况下，用父类的指针(或引用)调用子类对象，或者通过父类指针调用覆盖函数的时候(动态绑定)，实际上调用的是子类的覆盖版本，这种现象叫做多态

2.多态的作用：多态是父类的指针调用完全由指向的类型决定，这样就可以产生不同的效果

3.多态的条件

• 父子类之间有覆盖关系
• 必须通过引用或者指针指向子类

4.代码演示

class A
{
    int data;
public:
    A(int data) { this->data = data; }
    virtual void show() { cout << "A:" << data; }
};
class B:public A
{
    int data;
public:
    B():A(10) { data = 2; }
    void show() { cout << "B:" << data; }
};

int main()
{
    A a(1), *pa;
    B b, *pb;
    pa = &a; pa->show();//打印A中的show
    pb = &b; pb->show();//打印B中的show

    pa = &b; pa->show();//打印B中的show(多态实现)
    return 0;
}

5.错误代码演示与更正

class A
{
    int data;
public:
    A() { data=1; }
    void show() { cout << "A:" << data; }
};
class B:public A
{
    int data;
public:
    B() { data = 2; }
    void show() { cout << "B:" << data; }
};

int main()
{
    A a;
    B pb；
    pb = (B*)&a;//将A对象转换为B类型
    pb->show();//打印垃圾值
    return 0;
}

• 上面的代码，打印的是B的show()，因为没有函数virtual关键字，所以函数的调用看的是对象类型，此处的B的类型，所以调用的是B的show()。但是此种做法会打印垃圾值。
• 打印垃圾值原因：B类为8字节，A类为4字节。B中show()函数访问的是B类的后四节的data数据，现在pb指针指向的是4字节的空间，后面4字节不确定，因此为垃圾值。

• 上面的代码如果show函数加上virtual关键字，则不会产生错误，看如下代码

class A
{
    int data;
public:
    A() { data=1; }
    virtual void show() { cout << "A:" << data; }
};
class B:public A
{
    int data;
public:
    B() { data = 2; }
    void show() { cout << "B:" << data; }
};

int main()
{
    A a;
    B pb；
    pb = (B*)&a;//将A对象转换为B类型
    pb->show();//打印1,调用A中的show();
    return 0;
}

• 原因：此处调用的是A中的show()，A中的show()访问的是前4字节的数据，A的data存在于前4字节，所以打印A中的data

四、纯虚函数(抽象类、接口)

1.基本概念：纯虚函数一种特殊的虚函数，在许多情况下在基类中不对虚函数做出有意义的实现，而是把它定义为纯虚函数，它的实现由派生类实现

• 格式：virtual 返回类型 函数名(参数列表)=0;

2.抽象类：包含纯虚函数的类成为抽象类

• 特点：抽象类包含纯虚函数，不能定义对象，只能被继承。类中所有成员函数必须是公有的

3.接口：是抽象类的一部分，提供纯虚函数接口

4.注意

• 纯虚函数没有函数体
• 纯虚函数可以不在派生类中实现，则派生类接着作为抽象类存在

5.代码演示

class CNpc
{
public:
    virtual void PK()=0; //纯虚函数
};
class CNpc_1:public CNpc
{
public:
    void PK(){
        cout<<"CNpc_1 PK";
    }
};
class CNpc_2:public CNpc
{
public:
    void PK(){
        cout<<"CNpc_2 PK";
    }
};
int main()
{
    CNpc* p1=&CNpc_1;
    p1->PK(); //调用CNpc_1中的函数

    CNpc* p2=&CNpc_2;
    p2->PK(); //调用CNpc_2中的函数
}