1.多态分为两种

（1）编译时的多态：通过函数重载实现

（2）运行时的多态，通过虚函数实现，即动态联编

2.继承不是多态

class father
{
public:virtual void run(){cout<<"父跑"<<endl;}void jump(){cout<<"父跳"<<endl;}
};
class son:public father
{
public:void run(){cout<<"子跑"<<endl;}void jump(){cout<<"子跳"<<endl;}
};
int main()
{father *pf = new son;pf->run();pf->jump();delete p;return 0;
}

二、重载

1.操作符重载

2.函数重载

3.多重继承中的重载

三、动态联编

class father
{
public:virtual void Test(){cout<<"父"<<endl;}
};
class son:public father
{
public:void Test(){cout<<"子"<<endl;}
};
class daughter:public father
{
public:void Test(){cout<<"女"<<endl;}
};void one(father one){one.Test();}
void two(father *two){two->Test();}
void three(father &three){three.Test();}int main()
{int n;father *ps = new son;one(*ps);delete ps;              //1father *pd = new daughter;two(pd);delete pd;          //2father *pf = new father();three(*pf);delete pf;       //3return 0;
}

输出：

父
女
父
解释：

1.由于不是以指针或引用的方式调用，即使是virtual函数，也无法实现多态

2.以指针的方式调用虚函数，因此是多态

3.以引用的方式调用虚函数，因此是多态

class A
{int x;
public:A(){x = 1;cout<<"A"<<endl;}void get(){cout<<x<<endl;}
};
class B: public A
{int x;
public:B(){x = 2;cout<<"B"<<endl;}void get(){cout<<x<<endl;}
};
class C : public A
{int x;
public:C(){x = 3;cout<<"C"<<endl;}void get(){cout<<x<<endl;}
};
int main()
{A p;int choice;while(cin>>choice){switch(choice){case 1:p = A();break;case 2:p = B();break;case 3:p = C();break;}p.get();}return 0;
}

输出：A

输入：1

输出：A 1

输入：2

输出：A B 1

输入：3

输出：A C 1

不管输入什么，p.get();时都输出1，可见没有实现多态

class father
{
public:virtual void Test(){cout<<"父"<<endl;}
};
class son:public father
{
public:void Test(){cout<<"子"<<endl;}
};int main()
{father *pf = new son;pf->Test();pf->father::Test();return 0;
}

输出：

子

父

（4）直接调用非虚函数不会出现多态。

虚函数调用非虚函数，全部都能实现多态

father *pf = new son;
//先构造父，再构造子，但pf指向的是父的对象。因此pf只能调用father的成员，不能调用son的成员
delete pf;
//只析构父，不析构子，造成内存泄漏