//实现多态的三个条件
//1 要有继承
//2 要有虚函数重写
//3 用父类指针(父类引用)指向子类对象
//c++规定,当一个成员函数被声明为虚函数后,其派生类中的同名函数都自动成为虚函数。因此,在子类重新声明该虚函数时,可以加,也可以不加,但习惯上每一层声明函数时都加virtual,使程序更加清晰。
成员函数被重载的特征是:
(1)具有相同的作用域(即同一个类定义中);
(2)函数名字相同
(3)参数类型,顺序 或 数目不同(包括const参数和非const函数)
(4)virtual关键字可有可无。
覆盖是指派生类重新实现(或者改写即重写)了基类的成员函数,其特征是:
(1)不同的作用域(分别位于派生类和基类中);(即虚函数的重写)
(2)函数名称相同
(3)参数列表完全相同;
(4)基类函数必须是虚函数。
(即我们可以得到,覆盖只是针对于虚函数)
隐藏是指派生类的成员函数遮蔽了与其同名的基类成员函数,具体规则如下:
(1) 派生类的函数与基类的函数同名,但是参数列表有所差异。此时,不论有无virtual关键字,基类的函数在派生类中将被隐藏。(注意别与重载混合)
(2)派生类的函数与基类的函数同名,参数列表也相同,但是基类函数没有virtual关键字。此时,基类的函数在派生类中将被吟唱。(注意别与覆盖混合)
1.虚函数(impure virtual)
C++的虚函数主要作用是“运行时多态”,即动态联编,父类中提供虚函数的实现,为子类提供默认的函数实现。
子类可以重写父类的虚函数实现子类的特殊化。
2.纯虚函数(pure virtual)
C++中包含纯虚函数的类,被称为是“抽象类”。抽象类不能使用new出对象,只有实现了这个纯虚函数的子类才能new出对象。
C++中的纯虚函数更像是“只提供申明,没有实现”,是对子类的约束,是“接口继承”。
C++中的纯虚函数也是一种“运行时多态”,动态联编。
class A
{
public:
virtual void out1(string s)=0;//纯虚函数
virtual void out2(string s)//虚函数
{
cout<<"A(out2):"<<s<<endl;
}
};
3.普通函数(no-virtual)
普通函数是静态编译的,没有运行时多态,只会根据指针或引用的“字面值”类对象,调用自己的普通函数。
普通函数是父类为子类提供的“强制实现”。
因此,在继承关系中,子类不应该重写父类的普通函数,因为函数的调用至于类对象的字面值有关。
===============================================================
#include <iostream>
using namespace std;
class Base
{
public:
virtual void f(float x){ cout << "Base::f(float) " << x << endl; }
void f(int x){ cout << "Base::f(int) " << x << endl; } //重载
void g(float x){ cout << "Base::g(float) " << x << endl; }
void h(float x){ cout << "Base::h(float) " << x << endl; }
};
class Derived : public Base
{
public:
virtual void f(float x){ cout << "Derived::f(float) " << x << endl; } //重写
void g(int x){ cout << "Derived::g(int) " << x << endl; } //隐藏
void h(float x){ cout << "Derived::h(float) " << x << endl; } //隐藏
};
void main(void)
{
Derived d;
Base *pb = &d;
Derived *pd = &d;
// Good : behavior depends solely on type of the object
pb->f(3.14f); //运行结果: Derived::f(float) 3.14
pd->f(3.14f); //运行结果: Derived::f(float) 3.14
// Bad : behavior depends on type of the pointer
pb->g(3.14f); //运行结果: Base::g(float) 3.14
pd->g(3.14f); //运行结果: Derived::g(int) 3
// Bad : behavior depends on type of the pointer
pb->h(3.14f); //运行结果: Base::h(float) 3.14
pd->h(3.14f); //运行结果: Derived::h(float) 3.14
}
===========================================
#include <iostream>
using namespace std;
class Base {
public:
virtual void f(int a) {
cout << "virtual Base::f(int a)" << endl;
}
void f(double d) { //重载
cout << "Base::f(double d)" << endl;
}
};
class Derived : public Base {
public:
void f(double d) { //隐藏
cout << "Derivd::f(double d)" << endl;
}
};
int main() {
Derived d;
d.f(3);
d.f(2.5);
Derived *pd = new Derived();
pd->f(3);
pd->f(2.5);
Base b;
b.f(5);
b.f(3.5);
Base *pBase = new Derived();
pBase->f(5);
pBase->f(3.5);
}