C++（14）：OOP之核心——多态（Polymorphsim）

引言

多态，Polymorphsim，多种状态，面向对象程序设计的核心。

据说，这是OOP程序员在应聘的时候，第一大考点！！！！！！

就我目前的认知水平来看，多态的出现，是为了在庞大的软件工程里，降低开发的复杂度。

e.g. 一个软件工程量很大，通过定义一些接口，interface，不同的人按照这些接口所指定的规则（输入、输出），

去实现具体的内容。最后，软件统一整合的时候，才能对接得上，相当于是协作关系。

不过我觉得吧，定义一堆函数，不也就可以吗？找xxx去实现函数a，找yyy去实现函数b。这样看起来，似乎也可以啊……

难道这成了面向过程的了？难道这样不能大家一起合作开发吗？

暂时还是没有太能理解这种设计思想……哎…………【注意】后面一个案例，就可以体现。没有多态，开发起来很麻烦！

按照百度百科的说法，在OOP中，接口的不同实现方式，就叫做多态。

如果某种程序设计语言，有对象，但是不支持多态，那么只能叫基于对象（object based），不能叫面向对象（object oriented）。

现在也没太能理解这种意思。

反正我现在的理解就是，运用多态，似乎可以更好地让一群人分工合作，协同开发。类似于自己制定的一套规范，标准。还有，解耦合？没懂……

就像当时看一些JAVA框架的时候，e.g. struts，就相当于制定了一套规范。e.g. MVC，每一个view（jsp）的下一步一定是调到一个controller（java）去…

这样，好像就是行业标准吧。行业标准似乎就是为了实现大统一，只要我们都符合这个标准，只要都按照这种规范去开发，你能用我的，我也能用你的。

就像用USB线给手机充电一样。普通USB数据线，不管是三星，还是小米，还是华为，只要这些手机的充电口都统一符合“采用某种USB接口研发、生产制造”的标准，那这些手机的充电线是可以通用的。至于手机里面怎么充电的，是什么电池，容量多少，好像并不关心。手机充电头那边是怎么把220V转成5V，1A的输出，也无所谓。只在乎“你有android手机的充电线吗？”这句话。

再举一个“多态”的例子。

我听别人说的。

一位老板，一声令下，“走吧！”

司机，开左前车门，从左前车门上车，发动汽车。

保镖，开右后车门，请老板上车。待老板上车后，自己开右前车门，上车。

老板，从右后车门，上车。

秘书，开左后车门，从左后车门上车。

尽管，同一个“函数”也好、“命令”也好，但是，不同的角色，不同的人，却有不同的动作和响应。这就是多态。

而不是需要老板说，司机，你干嘛干嘛，保镖，你干嘛干嘛，小秘，你又干嘛干嘛。这样累不累？

【经典案例】

清华的某位教授说，什么叫经典例题？

1. 本来就很经典；

2. 每次做，都会有新的收获！

#include <iostream>
#include <string>
using namespace std;


class CAnimal
{
public:
	CAnimal();
	virtual ~CAnimal();

	virtual void showName() const{
		cout<<"动物：我不知道我是谁"<<endl;
	}

	virtual void say() const{
		cout<<"动物：我不知道怎么叫"<<endl;
	}

	virtual void eat() const{
		cout<<"动物：我不知道吃什么"<<endl;
	}

protected:
	string name;

private:

};

CAnimal::CAnimal()
{
}

CAnimal::~CAnimal()
{
}


class CCat : public CAnimal
{
public:
	CCat();
	~CCat();

	void showName() const{
		cout<<"动物：我是猫"<<endl;
	}

	void say() const{
		cout<<"动物：喵喵喵"<<endl;
	}

	void eat() const{
		cout<<"动物：我吃鱼"<<endl;
	}


private:

};

CCat::CCat()
{
}

CCat::~CCat()
{
}

class CDog : public CAnimal
{
public:
	CDog();
	~CDog();

	void showName() const{
		cout<<"动物：我是狗"<<endl;
	}

	void say() const{
		cout<<"动物：汪汪汪"<<endl;
	}

	void eat() const{
		cout<<"动物：我啃骨头"<<endl;
	}

private:

};

CDog::CDog()
{
}

CDog::~CDog()
{
}

class CFood
{
public:
	CFood();
	virtual ~CFood();

	virtual void showName() const{
		cout<<"食物：我不知道我是什么食物"<<endl;
	}

private:

};

CFood::CFood()
{
}

CFood::~CFood()
{
}

class CFish : public CFood
{
public:
	CFish();
	~CFish();

	void showName() const{
		cout<<"食物：我是鱼"<<endl;
	}

private:

};

CFish::CFish()
{
}

CFish::~CFish()
{
}

class CBone : public CFood
{
public:
	CBone();
	~CBone();

	void showName() const{
		cout<<"食物：我是骨头"<<endl;
	}

private:

};

CBone::CBone()
{
}

CBone::~CBone()
{
}

class CMaster
{
public:
	CMaster();
	~CMaster();

	void feed(CAnimal & an, CFood & food) const{
		an.showName();
		an.say();
		food.showName();
		an.eat();
	}

private:

};

CMaster::CMaster()
{
}

CMaster::~CMaster()
{
}

int main () {

	CAnimal * an = new CCat;
	CFood * food = new CFish;

	CMaster * master = new CMaster;
	master->feed(*an,*food);


	delete an;
	delete food;
	delete master;


	system("pause");
	return 0;

}

动物：我是猫
动物：喵喵喵
食物：我是鱼
动物：我吃鱼

主人类中，feed函数，本来按理说就应该填一个动物，填一种食物，就好。

多态提供了足够的灵活性！

主人类中，代码可以写得很少啊！！！（有助于开发，特别是有助于减少架构师的工作量…）

如果没有多态，主人类中，要重载至少2个函数嘛。

一个给猫喂鱼，一个给狗喂骨头。

要是有更多的子类，主人类的开发要被写死！而且，维护起来很困难啊！

多态概述

据说，多态的形式分2种。我直接从PPT上摘下来。

Polymorphism is one of three keys in OOP and supports
– function overloading and operator  overloading at  compile time（编译时多态）
– function  overriding at  run-time associate many meanings to one function （运行时多态）

Run-time polymorphism
– enable programmers to design a common interface that can be used on different but related objects
– reduce complexity and development time

Compile-time polymorphism
– apply static binding
– advantage of fast speed
– realized by function overloading and operator overloading

Run-time polymorphism
– apply dynamic binding
– advantage of enhanced flexibility
– realized by inheritance + virtual functions

In C++, redefining a virtual function in a derived class is called overriding a function.

绑定的方式

静态绑定，static binding, early binding，在编译时进行绑定 at compile time.

动态绑定，dynamic binding, late binding，在运行时进行绑定 at run-time.

在JAVA里面，多态是可以通过写一个interface，然后某个class去implement这个接口，再override接口里的函数，实现。

好像也可以通过直接用class A 去 extends class B，并override B中的函数，实现。

在C++里，使用abstract base class和virtual function实现。

如果A是一个class，

A * a = new A;

a.fun1();

属于静态绑定，编译时就知道要调用A的fun1()函数了。

如果A是一个class，A中的fun1()前面用了virtual修饰词，

B又继承了A，如果在B中override了fun1()这个函数，

A * a = new B;

a.fun1();

属于动态绑定，只有到运行时才知道，虽然是a.fun1();，但其实是要调用B的fun1()函数。

我暂时不明白，为什么只有到运行时，才会知道……

难道在编译的时候，编译器看不懂我写的代码？ （明明new的就是B啊）？难道只有在运行时，才会发现new的是B？

这是什么情况……

有一种官方的说法。

Casting between the base class and the derived class（ 互相转型，3种情况！）
– can assign a derived-class object to a  base-class object // 1. 在assign的时候，可以向上转型！
– can copy the address of a derived-class object to a pointer of a base-class object // 2. 可以把派生类的地址assign给指向基类的指针
– a derived-class object can be a reference to base-class object // 3. 可以写 B0 & b0 = D1; 
But！ can only access members in the base class, not members in the derived class （ 都只能范围基类中的成员！不能访问派生类中的成员！）

虚函数

Virtual functions makes that a pointer or reference of a base-class object can be applied onto a derived-class object（注意，也 只能是虚函数加上pointer or ref才会体现，assign也是不行的！）

Virtual functions tell the compiler
– don’t know how function is implemented
– wait until used in program
– get implementation from object instance
– call dynamic (late) binding

（只要写了virtual function，编译器自己就会去等，直到运行时…）

If a function f() in the base class is virtual, then all f()‘s in the derived classes are virtual.

（只要父类中f是虚函数，即用virtual声明了，则之后在它的所有派生类中，f这个函数都是虚函数，即时没有用virtual声明）

A virtual function must be a member function of a class cannot be global, static or friend.

Destructors can be virtual but constructors cannot be virtual.

Major disadvantage: more storage overhead + running slower

#include <iostream>
#include <cstdlib>
#include <cstring>

using namespace std;

class B0 {   
public: 
	void ShowFun() { //not virtual
        cout << "B0::ShowFun()" << endl; } 
};

class C0 : public B0 {   
public: 
	virtual void ShowFun() { //virtual
    	cout << "C0::ShowFun()" << endl; } 
};

class C1 : public C0 {   
public: 
	void ShowFun() { //virtual
        cout << "C1::ShowFun()" << endl; } 
};

class C2 : public C1 {   
public: 
	void ShowFun() { //virtual
        cout << "C2::ShowFun()" << endl; } 
};

void FunPtr(C0 *ptr) {
    ptr->ShowFun();
}


int main() 
{
    B0 w, *p; C0 x, *q;
    C1 y; C2 z;
    p = &w; p->ShowFun();
    p = &y; p->ShowFun(); //Q1: what happen??
    q = &x; FunPtr(q);    //Q2: which to call? 
    q = &y; FunPtr(q);
    q = &z; FunPtr(q); 
	//q = &w; FunPtr(q);    //Q3: what happen??
	//FunPtr(&w); 			//Q4: what happen?? => cannot covert from B0* to C0*; but the reverse can
	//FunPtr(p);			//Q5: what happen?? => cannot covert from B0 to C0* ; but the reverse can
	
	system("pause");
    return 0;	
}

结果。

B0::ShowFun()  // p是指向B0的指针，输出是B0

B0::ShowFun()  // 不是虚函数，不会访问派生类的成员
C0::ShowFun()  // 虚函数。 showFun在B0里已经是虚函数了。在子类中也会是虚函数！尽管override了！
C1::ShowFun()  // 
C2::ShowFun()

【注意】

1. 如果某个类是基类，立即把它的析构函数写成虚函数！

【经典案例】

class A { public:
~A() { cout << “A::~A()\n”;}
};
class C : public A {
int * iary;
public:
C(int i) { iary = new int [i]; }
~C() {
delete [] iary;
cout << “C::~C()\n”; }
};

//in main()
A *pa = new C(10);
delete pa;

派生类对象开辟的内存，并没有回收！！！
所以，一定要把析构函数写成虚函数！！！

2. 尽量用父类去声明，尽管最后new出来的是子类！

和java里的写法一样。

List <Object> list = new ArrayList<Object> ();

如果用子类去声明的话，有可能会发生点不出来父类中写过的一些函数的情况。

e.g.  overloaded members in base classes cannot be accessed directly.

上一篇也提到过。

Review： C++多继承

#include <iostream>
using namespace std;


class CB0
{
public:
	CB0() {};
	~CB0() {};

	void fun() {
		cout<<"CB0::fun()"<<endl;
	}

	void fun(int i) {
		cout<<"CB0::fun(int i) "<<endl;
	}

};

class CD0 : public CB0
{
public:
	CD0() {};
	~CD0() {};

	void fun(int i) {
		cout<<"CD0::fun(int i) "<<endl;
	}
};

int main () {

	CB0 * obj1 = new CD0; // 父类声明，却有两个fun
	obj1->fun();
	obj1->fun(0);

	CD0 obj2;
	obj2.fun(0); // 子类声明，只有这一个了！

	system("pause");
	return 0;
}

结果。

CB0::fun()
CB0::fun(int i)
CD0::fun(int i)

因为没写虚函数，所以指针的值虽然保存的一个CD0对象的地址，但通过这个指针，fun也只能调用CB0的fun了。

如果用了虚函数

#include <iostream>
using namespace std;


class CB0
{
public:
	CB0() {};
	virtual ~CB0() {};

	virtual void fun() {
		cout<<"CB0::fun()"<<endl;
	}

	virtual void fun(int i) {
		cout<<"CB0::fun(int i) "<<endl;
	}
	
private:

};

class CD0 : public CB0
{
public:
	CD0() {};
	~CD0() {};

	virtual void fun(int i) {
		cout<<"CD0::fun(int i) "<<endl;
	}

private:

};

int main () {

	CB0 * obj1 = new CD0; // 父类声明，却有两个fun
	obj1->fun();
	obj1->fun(0); 

	CD0 d0;
	d0.fun(1); // 子类声明，只有一个fun。在子类中，override过什么，同名的就只有什么了。
	
	system("pause");
	return 0;
}

结果。

CB0::fun() // 这确实在调用父类的fun。
CD0::fun(int i) // 由于多态，调用子类的fun。一定要是整个函数一模一样，才算覆写！覆写≠重载！
CD0::fun(int i) // 本来就是用CD0声明的，所以肯定调用子类的。

【经典案例】吐血推荐！

class B { public:
void f() { cout << “Bf ”; }
virtual void g(){ cout << “Bg ”; }
void h() { g(); f(); }
virtual void m(){ g(); f(); }
};
class D : public B { public:
void f() { cout << “Df ”; }
void g() { cout << “Dg ”; }
void h() { f(); g(); }
void m(int i) {f(); g();}
};

//in main()
D d; B *pB = &d;
pB->f(); pB->g(); pB->h(); pB->m();

结果会是：

Bf Dg Dg Bf Dg Bf

pB->h(); h在B里不是虚函数，所以调用B的h()。

B的h里面，有g，而g是虚函数，所以调用D的g，输出Dg，

B的h里面，还有f，f不是虚函数，所以调用B的f，输出Bf。

同理，pB->m(); m()是在B里虚函数，但是D中没有override（ override一定要是两个函数一模一样！！！），只是又增加了一个void m(int i)的函数

所以调用B中的m，

B的m里面，有g，g是虚函数，调用D的g，输出Dg，

B的m里面，还有f，f不是虚函数，调用B的f，输出Bf

game over…

纯虚函数

（类似于Java里面的interface）

Pure virtual functions require no definition 

– force each derived classes to define its own version

Class with one or more pure virtual functions is abstract base class（注意，是抽象基类，不是虚基类。虚基类是虚拟继承里的概念！）
– can only be used as base class
– no objects can ever be created from it
because it doesn’t include complete definitions of all its members

抽象基类不能实例化！

If one derived class fails to define all pure virtual functions,
– also an abstract base class

如果抽象基类的派生类，没有重新定义所有的虚函数，那这个派生类依然是抽象基类，还是不能被实例化！

纯虚函数的声明方式。后面等于0，不要写函数体。

virtual void Area()=0; //pure virtual!