C++中多态使用详细讲解

大家都知道多态是面向对象编程的一个特性，简单点说:“一个接口，多种实现”，就是同一种事物表现出的多种形态。所有的面向对象编程的语言都有以下三种特性：继承、封装、多态。接下来我们要详细的聊一聊C++中的多态是如何应用的。

1.定义

• 多态按字面的意思就是多种形态。当类之间存在层次结构，并且类之间是通过继承关联时，就会用到多态。C++ 多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数。
• 多态就是同一个行为具有多个不同表现形式或形态的能力，指的就是行为的多态。比如动物的爬行行为,小狗老虎,兔子它们各自的爬行方式是不同的，再比如草本植物都有自己的药物功能，他们所对应的药物功能不一样。
• 其实多态就是同一个接口，使用不同的实例而执行不同操作，比如我们人类是一个基类，程序员和会计是两个不同的子类，他们都继承了人类的吃、喝、学习、工作等等很多的能力，但是程序员在继承基类的基础上，又学会了敲代码；会计学会了做账单。他们产生的效果也是不同，程序员写出了服务软件给我们生活带来了许多的方便，比如我们可以玩手机、网上购物等等。会计可以帮我们公司算账，计算我们每个人的工资，让我们劳有所得，每个人都可以拿到自己的劳动成果。

我们来看下面一个例子：

#include <iostream> 
using namespace std;
 
class Shape {
   protected:
      int width, height;
   public:
      Shape( int a=0, int b=0)
      {
         width = a;
         height = b;
      }
      virtual int area() // virtual是用来定义虚函数的，是C++继承里不可缺少的关键字，如果不用它，那么我们就不会达到多态的效果，我们调用的依然是基类的方法。
      {
         cout << "Parent class area :" <<endl;
         return 0;
      }
};
class Rectangle: public Shape{
   public:
      Rectangle( int a=0, int b=0):Shape(a, b) { }
      int area ()
      { 
         cout << "Rectangle class area :" <<endl;
         return (width * height); 
      }
};
class Triangle: public Shape{
   public:
      Triangle( int a=0, int b=0):Shape(a, b) { }
      int area ()
      { 
         cout << "Triangle class area :" <<endl;
         return (width * height / 2); 
      }
};
// 程序的主函数
int main( )
{
   Shape *shape;
   Rectangle rec(10,7);
   Triangle  tri(10,5);
 
   // 存储矩形的地址
   shape = &rec;
   // 调用矩形的求面积函数 area
   shape->area();
 
   // 存储三角形的地址
   shape = &tri;
   // 调用三角形的求面积函数 area
   shape->area();
   
   return 0;
}

2.作用

• 提高了代码的维护性(继承保证)
• 提高了代码的扩展性(由多态保证)
• 把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，以适应需求的不断变化

3.使用格式

多态的定义格式：就是父类的引用变量指向子类对象

父类类型 变量名 = new 子类类型();

变量名.方法名();

4.多态存在的必要条件

• 继承
• 重写
• 父类引用指向子类对象：Parent p = new Child(); 父类做形参,子类做实参

5.虚函数和纯虚函数

虚函数是C++类继承中必不可少的概念，我们要学好C++类的使用，就必须深刻的掌握虚函数

5.1 虚函数

虚函数 是在基类中使用关键字 virtual 声明的函数。在派生类中重新定义基类中定义的虚函数时，会告诉编译器不要静态链接到该函数。

我们想要的是在程序中任意点可以根据所调用的对象类型来选择调用的函数，这种操作被称为动态链接，或后期绑定。

5.2 纯虚函数

您可能想要在基类中定义虚函数，以便在派生类中重新定义该函数更好地适用于对象，但是您在基类中又不能对虚函数给出有意义的实现，这个时候就会用到纯虚函数。

我们可以把基类中的虚函数 area() 改写如下：

class Shape {
   protected:
      int width, height;
   public:
      Shape( int a=0, int b=0)
      {
         width = a;
         height = b;
      }
      // pure virtual function
      virtual int area() = 0;
};

= 0 告诉编译器，函数没有主体，上面的虚函数是纯虚函数。

5.3 抽象类

当一个类中存在了纯虚函数，那么这个类就被称做抽象类

抽象类特点:

• 抽象类无法进行实例化
• 如果抽象类的子类没有重写纯虚函数，那么该子类也无法进行实例化

5.4 纯虚析构和虚析构函数

class Animal
{
public:
	Animal()
	{
		cout << "调用Animal的构造函数" << endl;
	}
	virtual void speak() = 0;
 
	~Animal()
	{
		cout << "调用Animal 的析构函数" << endl;
	}
};
{
	cout << "调用Animal的析构函数" << endl;	
}
class Cat :public Animal
{
public:
	Cat(string name)
	{
		cout << "调用Cat的构造函数" << endl;
		_name = new string(name);
	}
	virtual void speak()
	{
		cout << *_name<<"猫会说话" << endl;
	}
	string* _name;
	~Cat()
	{
		cout << "调用Cat的析构函数" << endl;
		if (_name != NULL)
		{
			delete _name;
		}
	}
};
void test()
{
	Animal* c = new Cat("Tom");
	c->speak();
	delete c;
}
int main()
{
	test();
	return 0;
}
// 输出结果：
调用Animal的构造函数
调用Cat的构造函数
Tom猫会说话
调用Animal的析构函数

我们发现当删除c对象时，没有调用子类中的析构函数，而子类中又申请了堆上的空间，那么这样就会造成内存泄漏。

那么我们如何保证调用子类中的析构函数呢？

这里我们就需要在父类的析构函数前面加上virtual来修饰，将父类析构函数做如下修改

//虚析构和纯虚析构都需要代码的实现
    virtual	~Animal()
	{
		cout << "调用Animal的析构函数" << endl;
	}
// 输出结果：
调用Animal的构造函数
调用Cat的构造函数
Tom猫会说话
调用Cat的析构函数
调用Animal的析构函数

上面我们使用的是虚析构函数来帮助我们解决内存泄漏的问题，这里我们也可以使用纯析构函数来帮助我们,将父类的析构函数改成：

virtual ~Animal() = 0;

我们这样写，程序会报错，原因是我们没有定义父类中的纯虚析构函数，加上定义

Animal::~Animal()
{
	cout << "调用Animal的析构函数" << endl;	
}

当在类外实现了纯虚析构的实现，编译器就不再会报错

总结:

• 纯虚析构函数和虚析构函数的共性：

  • 可以解决父类指针释放子类对象不干净的问题
  • 都需要具体的代码实现

• 纯虚析构函数和虚析构函数的不同：

  • 如果一个类中存在纯虚析构，这个类处于抽象类，不能进行实例化
  • 如果是虚析构，仍可以进行实例化

**注：**如果子类中没有堆区的数据，可以不用写纯虚析构或者虚析构

6.多态的底层原理

• 有继承关系

• 子类要重写父类中的虚函数

  有虚函数的类中会产生一个vfptr的指针和一个名为vftable的作用域，这个指针指向这个作用域，而在这个作用域中存在着被virtual修饰的函数的地址，如果没有重写父类中的虚函数，那么在子类将继承父类中的vftable，那么在调用speak函数时，永远调用的是父类中实现的函数。

7.多态的特点

7.1 多态中，编译看左边（静态绑定），运行看右边（动态绑定）

• 静态绑定

  在编译阶段能够确定方法在内存什么位置的就叫静态绑定，当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译不通过；如果有，编译通过。

• 动态绑定

  在运行阶段，父类对象类型在堆内存中创建的实际对象是子类对象，根据内存中真实的对象引用重新去给父类的方法表索引项赋值，这种通过程序运行过程动态创建对象方法表的定位方法的方式，一般称之为动态绑定。

7.2 向上转型和向下转型

• 向上转型

  子类引用的对象转换为父类类型称为向上转型。就是是将子类对象看成父类对象。此处父类对象可以是接口。

• 向下转型：把父类对象转为子类对象。