子类最好也加virtual

解决方式：在父类的析构函数加virtual，虚析构函数

delete后面是父类的指针，则只会执行父类的析构函数；

后面是子类的指针，则会执行子类和父类的析构函数。

因此在delete父类指针的时候，会造成内存泄露。

面向对象的三大特征：封装、多态、继承

静态多态（早绑定）： 

动态多态（晚绑定）：

在多态中，出现基类与派生类同名的虚函数，可以父类对象实例化子类，调用子类成员函数。

多态（静态多态，动态多态）

静态多态（早绑定）：就是函数名称相同的两个函数，形成了重载，但是里面的参数个数不同或者说是类型不同，在主函数中调用函数的时候，会根据参数类型或者是参数的个数，系统自动调用函数来执行

动态多态（晚绑定）：a为父类，b，c都继承了a类，a，b，c类中有共同的函数，在main函数中实例化一个a的对象，分别指向b，c两个类，这时候如果想要用实例化a的对象通过相同的函数分别指向b，c中的 与a相同的函数的时候，这是需要在a类的里面相同的函数前面加上virtual。

VIRTUAL只需要加在父类里边（析构函数和同名成员函数）就好，析构函数前边加是为了防止没有释放子类对象的内存导致内存泄露，同名成员函数前加是为了父类实例化的对象指针能够指向子类数据成员。

如果我们没有在子类当中定义同名的虚函数，那么在子类虚函数表中就会写上父类的虚函数的函数入口地址；如果我们在子类当中也定义了虚函数，那么在子类的虚函数表中我们就会把原来的父类的虚函数的函数地址覆盖一下，覆盖成子类的虚函数的函数地址，这种情况就称之为函数的覆盖。

#include"Exception.h"

#include<iostream>

using namespace std;

void Exception::printException()

{

cout <<"Exception --> printException()"<< endl;

}

#ifndef EXCEPTION_H

#define EXCEPTION_H

class Exception

{

public:

virtual void printException();

virtual ~Exception(){} //虚析构函数

};

#endif

#include "IndexException.h"

#include<iostream>

using namespace std;

void IndexException::printException()

{

cout <<"提示：下标越界"<< endl;

}

#ifndef INDEXEXCEPTION_H

#define INDEXEXCEPTION_H

#include "Exception.h"

class IndexException : public Exception

{

public:

virtual void printException();

};

#endif

#include<iostream>

#include"stdlib.h"

#include "IndexException.h"

using namespace std;

// void test()

// {

//     throw 10;//抛出异常 10

// }

// int main()

// {

//     try

//     {

//         test();

//     }

//     catch(int)

//     {

//         cout <<"exception"<< endl;

//     }

//     system("pause");

//     return 0;

// }

// void test()

// {

//     throw 0.1; //抛出异常 10

// }

// int main()

// {

//     try

//     {

//         test();

//     }

//     catch(double&e)

//     {

//         cout << e << endl;

//     }

//     system("pause");

//     return 0;

// }

// void test()

// {

//     throw IndexException();

// }

// int main()

// {

//     try

//     {

//         test();

//     }

//     catch(IndexException &e)

//     {

//         e.printException();

//     }

//     system("pause");

//     return 0;

// }

// void test()

// {

//     throw IndexException();

// }

// int main()

// {

//     try

//     {

//         test();

//     }

//     catch(Exception&e)

//     {

//         e.printException();

//     }

//     system("pause");

//     return 0;

// }

void test()

{

throw IndexException();

}

int main()

{

try

{

test();

}

catch(...)

{

cout <<"Exception"<< endl;

}

system("pause");

return 0;

}

#include <iostream>

#include "Bird.h"

using namespace std;

void Bird::foraging()

{

cout << "Bird --> foraging()" << endl;

}

void Bird::takeoff()

{

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

}

void Bird::land()

{

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

}

#ifndef Bird_H

#define Bird_H

#include "Flyable.h"

#include <string>

using namespace std;

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

{

public:

void foraging();//对于Bird类来说，其具有一个特有的成员函数foraging(觅食)

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

virtual void land();

};

#endif