C++之多态

目录

多态的定义及实现

多态的原理

---

多态的定义及实现

1、多态的概念：

当我们需要去完成某个行为，当不同的对象去完成时会产生出不同的状态。

2、虚函数：

被virtual关键字所修饰的类成员函数称为虚函数。

class A
{
  public:
    virtuit void print()
    {
      cout<<"virtuit void print()"<<endl;
    }
};

3、虚函数的重写（覆盖）：

派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名称、参数列表完全相同)，称子类的虚函数重写了基类的虚函数。

class A
{
  public:
      virtual void print()   //返回值类型、函数名称、参数列表完全相同
      {
        cout<<" A::virtuit void print()"<<endl;
      }
};

class B :: public A
{
  public:
      virtual void print()  //返回值类型、函数名称、参数列表完全相同
      {
        cout<<" B::virtuit void print()"<<endl;
      }
};

注意：在重写基类虚函数时，派生类的虚函数也可以不加virtual关键字，也可以构成重写(因为继承后基类的虚函数被继承下来了在派生类依旧保持虚函数属性),但不推荐这样去写

4、构成多态的两个条件： 

1、虚函数的重写（覆盖）
2、父类对象的指针或者引用去调用虚函数

如下：

class A
{
  public:
    virtual void print()  {
        cout<<" A::virtuit void print()"<<endl;
      }
};
class B : public A
{
  public:
    virtual void print()  {
        cout<<" B::virtuit void print()"<<endl;
      }
};
int main()
{
  A a;
  B b;
  A& fa=a;
  A& fb=b;
  fa.print(); //类对象的引用去调用虚函数
  fb.print(); //类对象的引用去调用虚函数
  return 0;
}

运行结果：

当我们用父类对象的引用去调用虚函数和用子类对象的引用去调用虚函数，运行输出的结果不同

5、 协变(基类与派生类虚函数返回值类型不同)

虽然协变可以要求返回值不同，但是要求基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用

class A
{
public:
    virtual  A& print() {   //返回基类的引用
        cout << " A::virtuit void print()" << endl;
        return *this;
    }
};

class B: public A
{
public:
    virtual B& print() {   //返回派生的引用
        cout << " B::virtuit void print()" << endl;
        return *this;
    }
};

6、关键字 override 和 final

1、override(覆写) 帮我们检查子类的虚函数是否重写了父类的虚函数

class A
{
public:
    virtual void print() {   
        cout << " A::virtuit void print()" << endl;
        return *this;
    }
};

class B: public A
{
public:
    virtual void print() override {  //加入关键字override
        cout << " B::virtuit void print()" << endl;
        return *this;
    }
};

将override关键字加入到子类虚函数的后面，如果子类虚函数没有完成对父类的虚函数重新，那么编译器就会报错。

2、final

final去修饰虚函数，表示该虚函数不能再被重写

class A
{
public:
    virtual void print() final {   //去修饰函数，表示该虚函数不能再被重写
        cout << " A::virtuit void print()" << endl;
    }
};

class B: public A
{
public:
    virtual void print()  {    //不能这样写，编译器会报错
        cout << " B::virtuit void print()" << endl;
    }
};

final去修饰类，表示这个类禁止其他类继承它

class A  final //去修饰类，表示该类不能再被继承
{};

class B: public A    //不能这样写，编译器会报错
{};

多态的原理

7、抽象类与纯虚函数

在虚函数的后面写上 =0 ，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。

class A  //抽象类
{
public:
  virtual void print()=0  //纯虚函数
  {}
}

class B :public A
{
  public:
    virtual void print()  //必须重写后才能实例化对象
    {
      cout<<"virtual void print()"<<endl;
    }
}

8、虚函数表指针和虚函数表

1、虚函数表指针和虚函数表的概念：

看以下代码：

class A
{
public:
	virtual void fun1() { cout << "A:: fun1()" << endl; }  //虚函数
private：
    int _a;
};

int main()
{
	A a; 
	return 0;
}

我们打开调试窗口观察：

分析：

这里除了_a成员，还多一个__vfptr放在对象的前面(注意有些平台可能会 放到对象的最后面，这个跟平台有关)，对象中的这个指针我们叫做虚函数表指针,一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中， 虚函数表也简称虚表。

2、虚函数表和虚函数表指针的作用：

看以下代码：

class A
{
public:
	virtual void fun1() { cout << "A:: fun1()" << endl; }  //虚函数
    int _a;
};

class B :public A
{
public:
	virtual void fun1() { cout << "B:: fun1()" << endl; } //重写fun1
    int _b;
};

fun(A& fa)
{
  fa.fun1()
}

int main()
{
	A a; 
	B b;
    fun(a);
    fun(b);

	return 0;
}

打开调试窗口：

观察发现

 总结：

1. 基类a对象和派生类b对象虚表是不一样的，这里我们发现Fun1完成了重写，所以b的虚表中存的是重写的A::Func1，所以虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数的覆盖。重写是语法的 叫法，覆盖是原理层的叫法。

2. 虚函数表本质是一个存虚函数指针的指针数组，一般情况这个数组最后面放了一个nullptr。

3.如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数

4.派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。

多继承中的虚函数表

class A
{
  public:
    virtual void print() {
      cout<<"class A"<<endl;
    }
  protect:
    int _a;
};

class B
{
  public:
    virtual void print() {
      cout<<"class B"<<endl;
    }
  protect:
    int _b;
};

class C:public A,public B
{
  public:
    virtual void print() {
      cout<<"class C"<<endl;
    }
  protect:
    int _c;
};

int main()
{
  A a;
  B b;
  C c;
  return 0;
}

观察调试窗口：

 还需注意：多继承派生类的未重写的虚函数放在第一个继承基类部分的虚函数表中

本篇就分享到这里，如果本文对您有帮助请点赞支持一下~

文章尚有不足，欢迎大牛指正.