浅谈C++多态性

多态概念：

• 一个借口，多种方法，程序在运行时才决定调用的函数，它是面向对象编程领域的核心概念。多态(polymorphism)，字面意思多种形状。
• C++多态性是通过虚函数来实现的，虚函数允许子类重新定义成员函数
  • 子类重新定义为override，或者称为重写
    • 重写的话可以有两种，直接重写成员函数和重写虚函数，只有重写了虚函数的才能算作是体现了C++多态性
• 多态与非多态的实质区别就是函数地址是早绑定还是晚绑定。如果函数的调用，在编译器编译期间就可以确定函数的调用地址，并生产代码，是静态的，就是说地址是早绑定的。而如果函数调用的地址不能在编译器期间确定，需要在运行时才确定，这就属于晚绑定。
• 作用
  • 而多态的目的则是为了接口重用。（ 封装可以使得代码模块化，继承可以扩展已存在的代码）
  • 也就是说，不论传递过来的究竟是那个类的对象，函数都能够通过同一个接口调用到适应各自对象的实现方法。
  • 最常见的用法就是声明基类的指针，利用该指针指向任意一个子类对象，调用相应的虚函数，可以根据指向的子类的不同而实现不同的方法。如果没有使用虚函数的话，即没有利用C++多态性，则利用基类指针调用相应的函数的时候，将总被限制在基类函数本身，而无法调用到子类中被重写过的函数。

• #include<iostream>
  using namespace std;
   
  class A
  {
  public:
  	void foo()
  	{
  		printf("1\n");
  	}
  	virtual void fun()
  	{
  		printf("2\n");
  	}
  };
  class B : public A
  {
  public:
  	void foo()
  	{
  		printf("3\n");
  	}
  	void fun()
  	{
  		printf("4\n");
  	}
  };
  int main(void)
  {
  	A a;
  	B b;
  	A *p = &a;
  	p->foo();
  	p->fun();
  	p = &b;
  	p->foo();
  	p->fun();
  	return 0;
  }

   

• 第一个p->foo()和p->fuu()都很好理解，本身是基类指针，指向的又是基类对象，调用的都是基类本身的函数，因此输出结果就是1、2。

•  第二个输出结果就是1、4。p->foo()和p->fuu()则是基类指针指向子类对象，正式体现多态的用法

  • p->foo()由于指针是个基类指针，指向是一个固定偏移量的函数，因此此时指向的就只能是基类的foo()函数的代码了，因此输出的结果还是1

  • 而p->fun()指针是基类指针，指向的fun是一个虚函数，由于每个虚函数都有一个虚函数列表，此时p调用fun()并不是直接调用函数，而是通过虚函数列表找到相应的函数的地址，因此根据指向的对象不同，函数地址也将不同，这里将找到对应的子类的fun()函数的地址，因此输出的结果也会是子类的结果4。
     

• //小结：1、有virtual才可能发生多态现象
  // 2、不发生多态（无virtual）调用就按原类型调用
  #include<iostream>
  using namespace std;
   
  class Base
  {
  public:
  	virtual void f(float x)
  	{
  		cout<<"Base::f(float)"<< x <<endl;
  	}
  	void g(float x)
  	{
  		cout<<"Base::g(float)"<< x <<endl;
  	}
  	void h(float x)
  	{
  		cout<<"Base::h(float)"<< x <<endl;
  	}
  };
  class Derived : public Base
  {
  public:
  	virtual void f(float x)
  	{
  		cout<<"Derived::f(float)"<< x <<endl;   //多态、覆盖
  	}
  	void g(int x)
  	{
  		cout<<"Derived::g(int)"<< x <<endl;     //隐藏
  	}
  	void h(float x)
  	{
  		cout<<"Derived::h(float)"<< x <<endl;   //隐藏
  	}
  };
  int main(void)
  {
  	Derived d;
  	Base *pb = &d;
  	Derived *pd = &d;
  	// Good : behavior depends solely on type of the object
  	pb->f(3.14f);   // Derived::f(float) 3.14
  	pd->f(3.14f);   // Derived::f(float) 3.14
   
  	// Bad : behavior depends on type of the pointer
  	pb->g(3.14f);   // Base::g(float)  3.14
  	pd->g(3.14f);   // Derived::g(int) 3 
   
  	// Bad : behavior depends on type of the pointer
  	pb->h(3.14f);   // Base::h(float) 3.14
  	pd->h(3.14f);   // Derived::h(float) 3.14
  	return 0;
  }

   

令人迷惑的隐藏规则

本来仅仅区别重载与覆盖并不算困难，但是C++的隐藏规则使问题复杂性陡然增加。
这里“隐藏”是指派生类的函数屏蔽了与其同名的基类函数，规则如下：
（1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual
关键字，基类的函数将被隐藏（注意别与重载混淆）。
（2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual
关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）。
上面的程序中：
（1）函数Derived::f(float)覆盖了Base::f(float)。
（2）函数Derived::g(int)隐藏了Base::g(float)，而不是重载。
（3）函数Derived::h(float)隐藏了Base::h(float)，而不是覆盖。
 

C++纯虚函数

 一、定义
  纯虚函数是在基类中声明的虚函数，它在基类中没有定义，但要求任何派生类都要定义自己的实现方法。在基类中实现纯虚函数的方法是在函数原型后加“=0”
  virtual void funtion()=0

二、引入原因
   1、为了方便使用多态特性，我们常常需要在基类中定义虚拟函数。
   2、在很多情况下，基类本身生成对象是不合情理的。例如，动物作为一个基类可以派生出老虎、孔雀等子类，但动物本身生成对象明显不合常理。

  为了解决上述问题，引入了纯虚函数的概念，将函数定义为纯虚函数（方法：virtual ReturnType Function()= 0;），则编译器要求在派生类中必须予以重写以实现多态性。同时含有纯虚拟函数的类称为抽象类，它不能生成对象。这样就很好地解决了上述两个问题。

三、相似概念
   1、多态性
  指相同对象收到不同消息或不同对象收到相同消息时产生不同的实现动作。C++支持两种多态性：编译时多态性，运行时多态性。
  a、编译时多态性：通过重载函数实现
  b、运行时多态性：通过虚函数实现。

2、虚函数
  虚函数是在基类中被声明为virtual，并在派生类中重新定义的成员函数，可实现成员函数的动态覆盖（Override）
  3、抽象类
  包含纯虚函数的类称为抽象类。由于抽象类包含了没有定义的纯虚函数，所以不能定义抽象类的对象。

静态多态

静态多态就是在系统编译期间就可以确定程序执行到这里将要执行哪个函数，例如：函数的重载，对象名加点操作符执行成员函数等，都是静态多态，其中，重载是在形成符号表的时候，对函数名做了区分，从而确定了程序执行到这里将要执行哪个函数，对象名加点操作符执行成员函数是通过this指针来调用的。

class A
{
public:
	void Set(int a)
	{
		_a = a;
	}
public:
	int _a;
};

int main()
{
	A a1;
	a1.Set(15);
	return 0;
}

汇编代码在此时就知道应该要去到哪个地方之行哪个函数，这就是静态多态，也叫编译时多态。

动态多态则是利用虚函数实现了运行时的多态，也就是说在系统编译的时候并不知道程序将要调用哪一个函数，只有在运行到这里的时候才能确定接下来会跳转到哪一个函数的栈帧。

在说动态多态之前我们先来看一下什么是虚函数，虚函数就是在基类中声明该函数是虚拟的（在函数之前加virtual关键字），然后在子类中正式的定义（子类中的该函数的函数名，返回值，函数参数个数，参数类型，全都与基类的所声明的虚函数相同，此时才能称为重写，才符合虚函数，否则就是函数的重载），再定义一个指向基类对象的指针，然后使该指针指向由该基类派生的子类对象，再然后用这个指针来调用改虚函数，就能实现动态多态。

下面我们通过一个例子来看一下利用虚函数实现的动态多态：

class A
{
public:
	A(int a = 10)
		:_a(a)
	{}
	 virtual void Get()
	{
		 cout << "A:: _a=" << _a << endl;
	}
public:
	int _a;
};

class B :  public A
{
public:
	B(int b = 20)
		:_b(b)
	{}
	void Get()
	{
		cout << "B:: _b=" << _b << endl;

	}

	int _b;
};

int main()
{
	A a1;
	B b1;
	A* ptr1 = &a1;
	ptr1->Get();

	ptr1 = &b1;
	ptr1->Get();
	
	return 0;
}

汇编代码做了一系列的指针解引用处理就是为了从虚函数表中找到相应的虚函数进行调用，从而实现了动态多态。

 

类的成员函数

• 成员函数的声明必须在类的内部。
• 成员函数的定义既可以在类的内部也可以在外部。
• 使用点运算符 . 调用成员函数。
• 必须对任何const或引用类型成员以及没有默认构造函数的类类型的任何成员使用初始化式。
• ConstRef::ConstRef(int ii): i(ii), ci(i), ri(ii) { }
• 默认实参： Sales_item(const std::string &book): isbn(book), units_sold(0), revenue(0.0) { }
• *this：
  • 每个成员函数都有一个额外的，隐含的形参this。
  • this总是指向当前对象，因此this是一个常量指针。
  • 形参表后面的const，改变了隐含的this形参的类型，如 bool same_isbn(const Sales_item &rhs) const，这种函数称为“常量成员函数”（this指向的当前对象是常量）。
  • return *this;可以让成员函数连续调用。
  • 普通的非const成员函数：this是指向类类型的const指针（可以改变this所指向的值，不能改变this保存的地址）。
  • const成员函数：this是指向const类类型的const指针（既不能改变this所指向的值，也不能改变this保存的地址）。

非成员函数

• 和类相关的非成员函数，定义和声明都应该在类的外部。