58. 继承与多态（下）-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_52137184/article/details/141225955

重写与重载

重载和重写有什么区别？什么时候是重载，什么时候是重写？

下面的继承方式有问题吗？为什么？

#include <cstdlib>
#include <iostream>

using namespace std;

class Parent
{
public:
    virtual void func()
    {
        cout<<"void func()"<<endl;
    }
    
    virtual void func(int i)
    {
        cout<<"void func(int i)"<<endl;
    }
    
    virtual void func(int i, int j)
    {
        cout<<"void func(int i, int j)"<<endl;
    }
};

class Child : public Parent
{
public:
    void func(int i, int j)//父类里声明了virtual，子类就自动得到了virtual，可以省略
    {
        cout<<"void func(int i, int j)"<<" "<<i + j<<endl;
    }
    
    void func(int i, int j, int k)//和父类中的func()是什么关系呢？
    {
        cout<<"void func(int i, int j, int k)"<<" "<<i + j + k<<endl;
    }
};

void run(Parent* p)
{
    p->func(1, 2);
}

int main(int argc, char *argv[])
{
    Parent p;
    
    p.func();//void func()
    p.func(1);//void func(int i)
    p.func(1, 2);//void func(int i, int j)
    
    Child c;
    
    //c.func();ops!子类无法调用继承的父类函数？
    //子类中的同名函数无法重载父类中的同名函数
    //c.Parent::func();//这样写没错，同名函数被隐藏了，要加作用域
    
    c.func(1, 2);//void func(int i, int j)  3
    
    run(&p);//void func(int i, int j)
    run(&c);//void func(int i, int j)  3
    
    cout << "Press the enter key to continue ...";
    cin.get();
    return EXIT_SUCCESS;
}
result：
void func()
void func(int i)
void func(int i, int j)
void func(int i, int j) 3
void func(int i, int j)
void func(int i, int j) 3
Press the enter key to continue ...

函数重载★（效率高，编译的时候就知道调用哪个函数，运行后直接调用）

必须在同一个类中进行---->重载必须发生在同一个作用域里面
子类无法重载父类的函数，父类同名函数将被覆盖
重载是在编译期间根据参数类型和个数决定调用函数

函数重写★（在编译的时候不知道，在运行的时候才具体去看）

必须发生于父类与子类之间
并且父类与子类中的函数必须有完全相同的原型
使用virtual声明之后能够产生多态
多态是在运行期间根据具体对象的类型决定调用函数

虚函数深入理解

是否可以将类的每个成员函数都声明为虚函数？

C++中多态的实现原理

当类中声明虚函数时，编译器会在类中生成一个虚函数表
虚函数表是一个存储类成员函数指针的数据结构
虚函数表是由编译器自动生成与维护的
virtual成员函数会被编译器放入虚函数表中
存在虚函数时，每个对象中都有一个指向虚函数表的指针

vtable是一个函数指针数组，包含了类中声明的所有虚函数的地址。如果子类重写了父类的某个虚函数，那么子类的vtable中对应位置的函数指针将指向子类重写的函数；如果子类没有重写某个虚函数，则vtable中对应位置的函数指针将指向父类中该虚函数的实现。

VPTR一般作为对象的第一个数据成员被C++编译器编译出来

下边的过程叫寻址

通过虚函数表指针VPTR调用重写函数是在程序运行时进行的，因此需要通过寻址操作才能确定真正应该调用的函数。而普通成员函数是在编译时就确定了调用的函数。在效率上，虚函数的效率要低很多。

对象中的VPTR指针什么时候被初始化？（构造函数的函数体执行之前完成的）

对象在创建的时候由编译器对VPTR指针进行初始化

只有当对象的构造完全结束后VPTR的指向才最终确定

父类对象的VPTR指向父类虚函数表
子类对象的VPTR指向子类虚函数表

当父类指针指向子类对象时，它实际上持有的是子类对象的地址。通过这个指针调用虚函数时，程序会根据该地址找到子类对象的vptr，进而通过vptr定位到子类的vtable，并从vtable中找到正确的函数指针进行调用。

构造函数中的“多态”

对象中的VPTR指针什么时候被初始化？

结论：构造函数中调用虚函数无法实现多态。

#include <cstdlib>
#include <iostream>

using namespace std;

class Parent
{
public:
    Parent()//构造函数
    {
        this->func();
    }
    
    virtual void func()
    {
        cout<<"void Parent::func()"<<endl;
    }
};

class Child : public Parent
{
public: 
    void func()//重写func()
    {
        cout<<"void Child::func()"<<endl;
    }
};

void run(Parent* p)//结合main发生，父类指针指向子类对象
{
    p->func();
}

int main(int argc, char *argv[])
{
    Child c;//为什么没有产生多态？
    //result：void Parent::func()
    cout << "Press the enter key to continue ...";
    cin.get();
    return EXIT_SUCCESS;
}
result：
void Parent::func()
Press the enter key to continue ...

构造函数中无法实现多态，如果执行的是父类构造函数，里面执行的肯定是父类的func()函数版本，如果执行的是子类构造函数，里面执行的肯定是子类的func()函数版本

纯虚函数

面向对象中的抽象概念

用Shape作为基类进行继承

#include <cstdlib>
#include <iostream>

using namespace std;

class Shape
{
public:
    virtual double area() = 0;
};

class Rectangle : public Shape
{	
private:
    double m_a;
    double m_b;
public:
    Rectangle(double a, double b)
    {
        m_a = a;
        m_b = b;
    }
    
    double area()
    {
        return m_a * m_b;
    }
};

class Circle : public Shape
{
private:
    double m_r;
public:
    Circle(double r)
    {
        m_r = r;
    }
    
    double area()
    {
        return 3.14 * m_r * m_r;
    }
};

void area(Shape* s)//用到了多态
{
    cout<<s->area()<<endl;
}

int main(int argc, char *argv[])
{
    Rectangle rect(2, 3);
    Circle circle(4);
    
    area(&rect);
    area(&circle);
    
    cout << "Press the enter key to continue ...";
    cin.get();
    return EXIT_SUCCESS;
}
result：
6
50.24
Press the enter key to continue ...

面向对象中的抽象类

抽象类可用于表示现实世界中的抽象概念
抽象类是一种只能定义类型，而不能产生对象的类
抽象类只能被继承并重写相关函数(抽象类的作用)
抽象类的直接特征是纯虚函数

纯虚函数是只声明函数原型，而故意不定义函数体的虚函数。

抽象类与纯虚函数

抽象类不能用于定义对象

class Shape
{
public:
    virtual double area() = 0;
};

抽象类只能用于定义指针和引用

main中： 
	area(&rect);
    area(&circle);

void area(Shape* s)//用到了多态
{
    cout<<s->area()<<endl;
}

抽象中的纯虚函数必须被子类重写（没有函数体，必须被重写函数体）

class Circle : public Shape
{
    double m_r;
public:
    Circle(double r)
    {
        m_r = r;
    }
    
    double area()
    {
        return 3.14 * m_r * m_r;
    }
};