c++ 面向对象 -- 多态

目录

多态基本概念

多态内部原理

多态的优点

纯虚函数和抽象类

虚析构和纯虚析构

---

多态基本概念

多态是c++面向对象三大特性之一

多态分为两类：

    a. 静态多态 ：函数重载和运算符重载属于静态多态，复用函数名

    b. 动态多态：派生类和虚函数运行时的多态

静态多态和动态多态的区别：

    a. 静态多态的函数地址早绑定 -- 编译阶段确定函数地址

    b. 动态多态的函数地址晚绑定 -- 运行阶段确定函数地址

动态多态的满足条件：

    a. 有继承关系

    b. 子类要重写父类的虚函数

重写：函数返回值类型  函数名 参数列表  完全相同。子类在重写时，关键字“virtual”可写可不写，不影响，但父类中必须有这个关键字。

动态多态的使用场景：

    a. 父类的指针或者引用 执行子类对象

 

例子：

#include
using namespace std;
//多态
// 动物类
class Animal
{
public:  
    void speak()
{
        cout << "animal is speaking" << endl;
    }
};
// 猫类
class Cat :public Animal
{
public:  
    void speak()
{
        cout << "cat is speaking" << endl;
    }
};
​
// 执行说话的函数
void DoSpeak(Animal &animal)
{
    animal.speak();
}
void test01()
{
    Cat cat;
    DoSpeak(cat);
}
int main()
{
    test01();
    return 0;
}

 

这段代码的本意是想执行“cat is speaking”, 但此时的输出为：

animal is speaking

原因是因为，此时是地址早绑定，在编译的阶段函数的地址就已经确定了，不管传进什么参数，都执行的是“animal is speaking”函数。

如果想执行“cat is speaking”，那么这个函数的地址就不能提前绑定，需要在运行时候在绑定地址，也就是地址晚绑定。

具体做法：需要在Animal类中的speak函数前加入关键字“virtual”，使之变为虚函数，就可以达到我们想要的目的了。

class Animal
{
public:  
    //虚函数
    virtual void speak()
{
        cout << "动物在说话" << endl;
    }
};

此时在输出就为：

cat is speaking

多态内部原理

class Animal
{
public:  
    //虚函数
   void speak()
{
        cout << "动物在说话" << endl;
    }
};
​
void test02()
{
    cout << " sizeof Animal = " << sizeof(Animal) << endl;
}

 

当不加关键字“virtual”时， sizeof(Aniaml) 是多少呢？

输出：sizeof Animal = 1

class Animal
{
public:  
    //虚函数
   virtual void speak()
{
        cout << "动物在说话" << endl;
    }
};
​
void test02()
{
    cout << " sizeof Animal = " << sizeof(Animal) << endl;
}

当加上关键字"virtual", sizeof(Aniaml) 是多少呢？

输出：sizeof Animal = 4

加上“virtual”之后，Animal内部结构发生了改变，会形成一个虚函数指针，指向虚函数表，表内记录的是虚函数的地址。当子类重写父类虚函数的时候，子类中的虚函数表内部会替换成子类的虚函数地址。当父类的指针或者引用指向子类对象时，发生了多态。如图所示。

 

多态的优点

    a. 组织结构清晰

    b. 可读性强

    c. 对于前期和后期扩展和维护性强。

例子：简单计算器实现

#include
using namespace std;
//普通写法
class Calculator
{
public:  
    int getresult(string oper)
{
        if (oper == "+")
        {
            return m_Num1 + m_Num2;
        }
        else if (oper == "-")
        {
            /* code */
            return m_Num1 - m_Num2;
        }
         else if (oper == "*")
        {
            /* code */
            return m_Num1 * m_Num2;
        }
    }
    int m_Num1;
    int m_Num2;
};
void test01()
{
    Calculator c;
    c.m_Num1 = 10;
    c.m_Num2 = 10;
    cout << c.m_Num1 << " + " << c.m_Num2 << " = " << c.getresult("+") << endl;
    cout << c.m_Num1 << " - " << c.m_Num2 << " = " << c.getresult("-") << endl;
    cout << c.m_Num1 << " * " << c.m_Num2 << " = " << c.getresult("*") << endl;
}
​
int main()
{
    test01();
    return 0;
}

 

上述代码可以实现一个简单的计算机功能，但是如果想要拓展，或者加入新的功能，就得动用原代码，而且检查bug的时候，也要去动源码，这是不可取的。在真正开发的时候，提倡一种开闭原则：对扩展进行开放，对修改进行关闭。

#include
using namespace std;
//多态写法
//实现一个计算机的抽象类
class AbstractCalculator
{
public: 
    virtual int getResult()
{
        return 0;
    }
    int m_Num1;
    int m_Num2;
};
​
// 加法类 
class AddCalculator :public AbstractCalculator
{
public:
    int getResult()
{
        return m_Num1+m_Num2;
    }
};
// 减法类 
class SubCalculator :public AbstractCalculator
{
public:
    int getResult()
{
        return m_Num1-m_Num2;
    }
};
// 乘法类 
class MulCalculator :public AbstractCalculator
{
public:
    int getResult()
{
        return m_Num1*m_Num2;
    }
};
​
void test02()
{
    AbstractCalculator *abc = new AddCalculator;
    abc->m_Num1 = 10;
    abc->m_Num2 = 10;
    cout << abc->m_Num1 << " + " << abc->m_Num2 << " = " << abc->getResult() << endl;
    delete abc;
}
int main()
{
    test02();
    return 0;
}

 

纯虚函数和抽象类

 

在多态中，通常父类中的虚函数的实现是没有意义的，主要都是调用子类重写的内容，因此可以将虚函数改为纯虚函数。当类中有纯虚函数，这个类也被称为抽象类。

纯虚函数的语法：virtual   返回值类型 函数名 （参数列表） =  0；

抽象类特点：

    a. 无法实例化对象

    b. 子类必须重写抽象类中的纯虚函数，否则也属于抽象类。

虚析构和纯虚析构

问题：多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的虚构代码。

解决方式：将父类中的析构函数改为虚析构或者纯析构

虚析构和纯析构共性：

    a. 可以解决父类指针释放子类对象

    b. 都需要有具体的函数实现

虚析构和纯析构区别：

    a. 如果是纯虚析构，该类属于抽象类，无法实例化对象。

//虚析构
class Animal
{
  virtual ~Animal()
  {
    cout << “animal的析构代码” << endl;
  }
};

//纯虚析构
//需要声明，也需要实现
class Animal
{
  virtual ~Animal() = 0;
​
};
Animal::~Animal()
{
  cout << “animal的析构代码” << endl;
}