1，什么是多态？

多态是指同样的消息被不同类型的对象界首市导致的不同行为，所谓小学时只对类的成员函数调用，不同的行为是指不同的实现，也就是调用了不同的函数。多态性提供接口与具体实现之间的另一层隔离，同时创建了使程序具有扩展性。事实上在程序设计中经常使用多态，的特性，最近简单的例子就是运算符对不同类型的数据对象运算。

多态的类型一般分为两类：

静态多态（编译时多态，早绑定）：函数重载、运算符重载、重定义

动态多态（运行时多态，晚绑定）：虚函数父类指针（引用）保存子类空间地址的目的就是让算法通用。

2，什么是虚函数？

1.如何实现父类对各个派生子类的操作？

这里的操作是在继承父类成员的条件下，对子类继承的成员的操作，也就是调用

首先要实现父类对各个派生子类的操作，我们需要父类指针保存子类空间，利用这个方式实现父类算法通用。

总结：通过构建父类指针保存子类的空间，实现对各个子类的操作（实际上这里还并不行，但这是实现该功能的前提）！

在这个基础上，构建虚函数或者纯虚函数他才会成立，在主函数中有应当如何去调用，都是父类指针保存子类空间的这个前提！！

2，父类指针保存子类空间产生的问题。

我们的目的是需要操作各个子类，虽然实现了如何访问哥哥派生子类，但实际上还并未能操作子类。

例：

#include<iostream>
using namespace std;
class animal
{
public:
  void nameshow()
  {
    cout << "我是什么动物" << endl;
  }
};
class cat :public animal
{
public:
  void nameshow()
  {
    cout << "我是猫" << endl;
  }
};
int main()
{
  //通过父类指针保存子类空间，实现对各个派生类的操作
  animal* p = new cat;
  //但我们这里想要调用的是子类的成员，但结果是父类的成员
  p->nameshow();
  return 0;
}

由上例知道，通过父类指针保存子类空间是没问题的，但因为你是父类指针，调用时不是操作子类，而是父类，故还并未实现父类对子类的操作，此时我们在定义父类成员（一般为函数）时就添加了关键词virtual，也就是虚函数，引入虚函数，我们可以实现父类对子类的调用。

3，虚函数的定义

父类成员函数前加virtual修饰。

#include<iostream>
using namespace std;
class animal
{
public:
  virtual void nameshow()
  {
    cout << "我是什么动物" << endl;
  }
};
class cat :public animal
{
public:
  void nameshow()
  {
    cout << "我是猫" << endl;
  }
};
class dog :public animal
{
public:
  void nameshow()
  {
    cout << "我是狗" << endl;
  }
};
int main()
{
  //通过父类指针保存子类空间，实现对各个派生类的操作
  animal* p1 = new cat;
  animal* p2 = new dog;
  //成功调用
  p1->nameshow();
  p2->nameshow();
  return 0;
}

通过关键词virtual我们将成员函数定义为虚函数，此时父类指针指向子类空间时，我们调用的就是子类的这个成员函数。

多态条件：有继承、子类重写父类的虚函数，父类指针指向子类空间。

我们可将子类继承父类的成员当做链接父类与子类的桥梁，父类指针指向各个子类空间就是实现各个桥梁，virtual就是实现父类通过桥梁到子类。

4，虚函数的动态绑定机制

当类中的成员函数被virtual修饰，那么这个函数就是虚函数，并且就会产生一个虚函数指针，指向了一张虚函数表（vftable），如果这个函数没有涉及到继承，这时虚函数表中记录着当前虚函数入口地址。

此时子类如dog：

可以看到子类会把父类的虚函数指针继承过来，同时把虚函数表继承过来，但虚函数表会被重写，可以看到上图中的表发生了改变，此时入口地址也发生了改变，此时调用时因为索引（地址）发生了改变，故调用的是子类的中的成员函数。

5，重载，重定义，重写的区别

重载：同一作用域，同名函数，参数的顺序、个数、类型不同都可以重载。函数的返回值类型不能作为重载条件（函数重载、运算符重载）。

重定义：有继承，子类重定义父类的同名函数（非虚函数），参数顺序、个数、类型可以不同。子类的同名函数会屏蔽父类的所有同名函数（可以通过作用域解决）。

重写（覆盖）：有继承，子类重写父类的虚函数。返回值类型、函数名、参数顺序、个数、类型都必须一致。

3，纯虚函数

我们可以发现如果基类一定派生出子类，而子类一定会重写父类的虚函数，也就是子类函数有自己的功能，那么父类的虚函数中的函数体感觉是无意义（我们既不需要调用它，在设计时他也是一个一个模糊的函数），那么可不可以不写父类虚函数的函数体呢？当然是可以的，而这就是纯虚函数。

纯虚函数的定义方式:

class 父类名
{
public:
//纯虚函数
virtual void speak(void)=0;
};

我们以一个实现对各个形状面积的计算的纯虚函数来实现。

include<iostream>
using namespace std; 
class Shape
{
  public:
    //定义纯虚函数 
    virtual double Getarea(void)=0;
        //也可以定义虚函数virtual double Getarea(void){return 0;}
    void print()
    {
      cout<<"调用基类对象的成员函数"<<endl;
    }
}; 
class Rectangle:public Shape
{
  public:
    void print()
    {
      cout<<"调用派生类对象（Rectangle）的成员函数"<<endl;
    }
    Rectangle(double x,double y)
    {
      Length=x;
      Width=y;
    }
    double Getarea()
    {
      return Length*Width;
    }
  private:
      double Length,Width;
};
class Circle:public Shape
{
  public:
    void print()
    {
      cout<<"调用派生类对象（Circle）的成员函数"<<endl;
    }
    Circle(double x)
    {
      Radious=x;
    }
    double Getarea()
    {
      return 3.14*Radious*Radious;
    }
  private:
      double Radious;
};
int main()
{
  Shape *p1=new Rectangle (2.2,2.0);
    Shape *p2=new Circle (1.0);
  cout<<"矩形面积为"<<p1->Getarea()<<endl;
  cout<<"圆面积为："<<p2->Getarea()<<endl;
  return 0;
}

有纯虚函数的类我们称作抽象类，对于抽象类是无法实例化对象的。

这里shape a；就会报错，已经无法实现实例化对象。

虚函数和纯虚函数的区别：

虚函数：virtual修饰有函数体不会导致父类为抽象类。

纯虚函数：virtual修饰，=0，没有函数体导致父类为抽象类。子类必须重写父类的所有纯虚函数。

4，虚析构函数

顾名思义，就是虚函数的析构函数。

因为之前我们在上例中都是用new开辟一个子类的空间，我们是在堆区上开辟的，若不释放就会造成内存泄漏。

如这里的animal*p=new cat;

delete p；

而在这里释放时直接delete这个父类指针，但是我们存放的是子类的空间，却是父类类型，故释放的应该是子类中属于父类的这一部分空间，但事实上我们new的是整个子类空间，因此在析构时只会调用父类中的析构，与子类无关，因此释放不彻底，有部分内存存在泄漏的可能。

那么如何去释放父类指针中的所有空间，这时候我们还是添加virtual，实现对父类指针中子类空间的全部释放，这就是虚析构。此时调用就会父类与子类的析构都会调用。

#include<iostream>
using namespace std;
class animal
{
public:
  animal()
  {
    cout << "调用父类构造" << endl;
  }
  virtual void nameshow()
  {
    cout << "我是什么动物" << endl;
  }
  ~animal()//virtual ~animal()
  {
    cout << "调用父类析构" << endl;
  }
};
class cat :public animal
{
public:
  cat()
  {
    cout << "调用cat构造" << endl;
  }
  void nameshow()
  {
    cout << "我是猫" << endl;
  }
  ~cat()
  {
    cout << "调用cat析构" << endl;
  }
};
class dog :public animal
{
public:
  dog()
  {
    cout << "调用dog构造" << endl;
  }
  void nameshow()
  {
    cout << "我是狗" << endl;
  }
  ~dog()
  {
    cout << "调用dog析构" << endl;
  }
};
int main()
{
  //通过父类指针保存子类空间，实现对各个派生类的操作
  animal* p1 = new cat;
  animal* p2 = new dog;
  //但我们这里想要调用的是子类的成员，但结果是父类的成员
  p1->nameshow();
  p2->nameshow();
  //释放空间，调用析构
  delete p1;
  delete p2;
  return 0;
}

这里未调用子类析构，可知这一部分空间未被删除，添加关键字virtual后：

可以发现父类保存的子类空间全部被释放掉。

1，纯虚构函数

纯虚析构函数的定义：

纯虚析构的本质：是析构函数，各个类的回收工作。而且析构函数不能被继承，必须为纯虚析构函数提供一个函数体。（而纯虚函数是没有函数体的）

纯虚析构函数：必须在类外实现.

例：

class animal
{
public:
  animal()
  {
    cout << "调用父类构造" << endl;
  }
  virtual void nameshow()
  {
    cout << "我是什么动物" << endl;
  }
  //纯虚析构函数
  virtual ~animal(void) = 0;
};
animal::~animal()
{
  cout << "调用父类析构" << endl;
}
class cat :public animal
{
public:
  cat()
  {
    cout << "调用cat构造" << endl;
  }
  void nameshow()
  {
    cout << "我是猫" << endl;
  }
   ~cat()
  {
    cout << "调用cat析构" << endl;
  }
};
class dog :public animal
{
public:
  dog()
  {
    cout << "调用dog构造" << endl;
  }
  void nameshow()
  {
    cout << "我是狗" << endl;
  }
   ~dog()
  {
    cout << "调用dog析构" << endl;
  }
};
int main()
{
  //通过父类指针保存子类空间，实现对各个派生类的操作
  animal* p1 = new cat;
  animal* p2 = new dog;
  //但我们这里想要调用的是子类的成员，但结果是父类的成员
  p1->nameshow();
  p2->nameshow();
  //释放空间，调用析构
  delete p1;
  delete p2;
  return 0;
}

这样的书写方式就是纯虚析构函数的实现，作用与上述虚析构函数的作用相同，两者都释放了父类和子类的空间，析构也都调用了。

2，虚析构和纯虚析构的区别

虚析构：virtual修饰，有函数体，不会导致父类为抽象类。

纯虚析构：virtual修饰，=0，函数体必须类外实现，导致父类为抽象类

c++学习之多态

1，什么是多态？

2，什么是虚函数？

1.如何实现父类对各个派生子类的操作？

2，父类指针保存子类空间产生的问题。

3，虚函数的定义

4，虚函数的动态绑定机制

5，重载，重定义，重写的区别

3，纯虚函数

4，虚析构函数

1，纯虚构函数

2，虚析构和纯虚析构的区别

热门文章

最新文章

相关课程

相关电子书

相关实验场景