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!