C++：多态（继承）

hello，各位小伙伴，本篇文章跟大家一起学习《C++：多态》，感谢大家对我上一篇的支持，如有什么问题，还请多多指教 ！

文章目录

• • :maple_leaf:多态的概念
  • :maple_leaf:继承中的多态
  • • 1.:leaves:虚函数表
    • :maple_leaf:多态原理

      🍁多态的概念

      在 C++ 中，多态性（Polymorphism）是面向对象编程中一个重要的概念，它允许使用统一的接口来操作不同的对象，从而提高代码的灵活性、可维护性和可扩展性。多态性的实现依赖于两种主要机制：编译时多态性（静态多态性）和运行时多态性（动态多态性）。

      1. 编译时多态性（静态多态性）：
      2. 在 C++ 中，编译时多态性主要通过函数重载和运算符重载来实现。这种多态性是在编译期间根据函数或运算符的参数类型和数量来选择调用的函数版本，称为静态绑定或早期绑定。
      3. 例如，函数重载允许在同一个作用域内定义多个函数名相同但参数列表不同的函数，编译器会根据调用时的参数类型来选择正确的函数。如下实现不同类型进行交换代码：

      void Swap(int& left, int& right)
      {
      	int temp = left;
      	left = right;
      	right = temp;
      }
      void Swap(double& left, double& right)
      {
      	double temp = left;
      	left = right;
      	right = temp;
      }
      void Swap(char& left, char& right)
      {
      	char temp = left;
      	left = right;
      	right = temp;
      }
      

      1. 运行时多态性（动态多态性）：
      2. 运行时多态性是通过虚函数和继承关系来实现的。这种多态性允许在程序运行时根据对象的实际类型来调用对应的函数，称为动态绑定或后期绑定。
      3. 在 C++ 中，通过在基类中将成员函数声明为虚函数（使用 virtual 关键字），允许派生类覆盖（override）这些虚函数。当通过基类指针或引用调用虚函数时，会根据实际指向的对象类型来决定调用哪个函数版本。

      下面是一个简单的示例，展示了 C++ 中的运行时多态性：

      #include 
      using namespace std;
      // Base class
      class Animal {
      public:
          // Virtual function
          virtual void speak() {
              cout 
      public:
          // Override the speak() function
          void speak() override {
              cout 
      public:
          // Override the speak() function
          void speak() override {
              cout 
          Animal *animal;
          Dog myDog;
          Cat myCat;
          // Pointer to Dog object
          animal = &myDog;
          animal-speak();  // Output: Dog barks!
          // Pointer to Cat object
          animal = &myCat;
          animal-speak();  // Output: Cat meows!
          return 0;
      }
      
      public:
       virtual void Func1()
       {
       cout 
      public:
      	virtual void Func1()
      	{
      		cout 
      		cout 
      		cout 
      public:
      	virtual void Func1()
      	{
      			cout 
      	Base b;
      	Derive d;
      	return 0;
      }
      
      public:
      	virtual void Mobility(Gun& gun) = 0;
      };
      class AK47 : public Gun
      {
      public:
      	void Mobility(Gun& gun)
      	{
      		cout 
      public:
      	void Mobility(Gun& gun)
      	{
      		cout 
      	gun.Mobility(gun);
      }
      int main()
      {
      	AK47 ak47;
      	M4A4 m4a4;
      	Gun& ak = ak47;
      	Gun& m4 = m4a4;
      	Func(ak);
      	Func(m4);
      	return 0;
      }
      
      public:
      	virtual void Func1()
      	{
      		cout 
      		cout 
      		cout 
      public:
      	virtual void Func1()
      	{
      			cout 
      	Base b;
      	Derive d;
      	Base& s1 = b;
      	Base& s2 = d;
      	s1.Func1();
      	s2.Func1();
      	return 0;
      }