#ifndef FLYABLE_H

#define FLYABLE_H

//在Flyable这个类中定义两个纯虚函数takeoff()和land()

class Flyable

{

public:

virtual void takeoff() = 0;

virtual void land() = 0;

};

#endif

#ifndef PLANE_H

#define PLANE_H

#include "Flyable.h"

#include <string>

using namespace std;

class Plane:public Flyable  //公有继承了Flyable

{

public:

void carry(); //Plane具有一个特有的成员函数carry(运输)

virtual void takeoff(); //实现了Flyable中的虚函数takeoff和land

virtual void land();

};

#endif

#include <iostream>

#include "Plane.h"

using namespace std;

void Plane::carry()

{

cout << "Plane --> carry()" << endl;

}

void Plane::takeoff()

{

cout << "Plane --> takeoff()" << endl;

}

void Plane::land()

{

cout << "Plane --> land()" << endl;

}

#include <iostream>

#include "stdlib.h"

#include "Bird.h"

#include "Plane.h"

using namespace std;

/*********************************************************************************************************/

/*RTTI

   1.Flyable类,成员函数: takeoff. land

   2.Plane类,成员函数: takeoff. land, carry

   3.Bird类,成员函数: takeoff. land, foraging

   4.全局函数doSomething(Flyable *obj)

*/

/*********************************************************************************************************/

void dosomething(Flyable *obj)

{

cout << typeid(*obj).name() << endl;  //打印传入的对象指针究竟是什么类型的对象

obj->takeoff();

if(typeid(*obj) == typeid(Bird)) //这里判断obj这个指针所指向的对象是不是Bird类型

{

Bird *bird = dynamic_cast<Bird *>(obj); //将obj这个指针通过dynamic_cast强制转换为Bird指针，并且将这个指针赋值给一个新的指针bird

bird->foraging(); //通过这个bird指针来调用foraging（觅食）这个成员函数

}

if(typeid(*obj) == typeid(Plane)) //这里判断obj这个指针所指向的对象是不是Bird类型

{

Plane *plane = dynamic_cast<Plane *>(obj); //将obj这个指针通过dynamic_cast强制转换为Plane指针，并且将这个指针赋值给一个新的指针plane

plane->carry(); //通过这个plane指针来调用carry（运输）这个成员函数

}

obj->land();

}

int main()

{

Bird b;

dosomething(&b);

system("pause");

return 0;

}

//Plan.cpp

#include <iostream>

#include "Plane.h"

using namespace std;

Plane::Plane(string code)

{

m_strCode = code;

}

void Plane::takeoff()

{

cout <<"Plane -takeoff" << endl;

}

void Plane::land()

{

cout <<"Plane --land" << endl;

}

void Plane::printCode()

{

cout <<m_strCode<< endl;

}

//main.cpp

#include<iostream>

#include<stdlib.h>

#include"FighterPlane.h"

using namespace std;

/*********************************************************************************************************/

/*接口类

    1. Flyable类,成员函数: takeoff、land

    2. Plane类,成员函数:构造函数、takeoff、land、 printCode ,数据成员:m_strCode

    3. FighterPlane类,成员函数:构造函数、takeoff. land

    4.全局函数flyMatch(Flyable *f1, Flyable *f2)

*/

/*********************************************************************************************************/

void flyMatch(Flyable *f1,Flyable *f2)

{

f1->takeoff ();

f1->land ();

f2->takeoff ();

f2->land ();

}

int main(void)

{

FighterPlane p1("001");

FighterPlane p2("002");

p1.printCode ();

p2.printCode ();

flyMatch(&p1,&p2);

return 0;

}

virtual不能加在构造函数前

virtual不能加在普通函数前

virtual不能加在静态成员前

virtual加在内联函数inline前，内联属性被覆盖

#include<iostream>

#include"Flable.h"

#include"Bird.h"

#include"Plane.h"

using namespace std;

void dosomething(Flable *obj)

{

cout << typeid(*obj).name() << endl;

obj->takeoff();

if (typeid(*obj)==typeid(Bird))

{

Bird *bird = dynamic_cast<Bird*>(obj);

bird->foraging();

}

if (typeid(*obj) == typeid(Plane))

{

Plane *plane = dynamic_cast<Plane*>(obj);

plane->carry();

}

obj->land();

}

int main(void)

{

Bird p;

dosomething(&p);

system("pause");

return 0;

}

typeid返回的对象类型

定义：在某基类中声明为 virtual 并在一个或多个派生类中被重新定 义的成员函数

语法：virtual 函数返回类型 函数名（参数表） { 函数体 }

用途：实现多态性，通过指向派生类的基类指针，访问派生类中同名覆盖成员函数

通过父类捕获子类异常

Exception 可以理解为类型 &e是抛出的异常值

异常和多态的关系

父类定义一个接口类

子类具体捕获不同的异常，抛出子类异常则都可以通过父类捕获

catch(Exception &e)

可以通过父类exception 捕获所有子类异常，并通过父类的虚函数调用不同子类的方法 

常见的异常

捕获异常的值例子

捕获异常的值