overload、override、overwrite总结

overload（重载），override（覆盖），overwrite（重写），有些资料写的是重载，覆盖，隐藏，其实说的是一回事，暂且就说是overload、override、overwrite 好了。

面向对象的重点就是多态，如果一个面向对象的程序没有体现出多态，那这个程序就是没有意义的。细思恐极，我在学校写的程序基本就没有这个概念。。

开始主题！

1.overload

区分overload非常简单，同一个类同一个函数名，参数不同（参数个数不同或者参数类型不同）就是overload！比如：

int fun（int count）和 int fun（float count）//参数类型不同

int fun（int count）和 int fun（int count，int sum）//参数个数不同

注意！只有返回值不同的不是overload。

int fun（int count）和 void fun（int count）//不是overload

但是，如果函数名有const修饰，是常成员函数，常成员函数可以理解为是一个“只读”函数，它既不能更改数据成员的值，也不能调用那些能引起数据成员值变化的成员函数，只能调用const成员函数和const成员变量。

int fun（int count）和 void fun（int count）const //是可以的，常成员函数

2.override

派生类继承基类，基类函数有virtual修饰，派生类函数名和函数参数与基类相同则是。主要用在对象的控制上。

#include <iostream.h>
class Base
{
public:
void f(int x){ cout << "Base::f(int) " << x << endl; }
void f(float x){ cout << "Base::f(float) " << x << endl; }
virtual void g(void){ cout << "Base::g(void)" << endl;}
};
class Derived : public Base
{
public:
virtual void g(void){ cout << "Derived::g(void)" << endl;}
};
void main(void)
{
Derived d;
Base *pb = &d;
pb->f(42); // Base::f(int) 42
pb->f(3.14f); // Base::f(float) 3.14
pb->g(); // Derived::g(void)
}

实例：所有的车进隧道，现要控制车灯打开。车有car，bus等区分，这里我们只要求所有车开灯而不关心是car还是bus，但是car和bus会展现各自开灯的特性。

3.overwrite

两个特点：

（ 1 ）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无 virtual 关
键字，基类的函数将被overwrite（注意别与overload混淆）。
（ 2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有 virtual
关键字。此时，基类的函数被overwrite（注意别与override混淆）。

总结起来就是基类的函数没有virtual，在派生类中存在同名函数就是overwrite。

class Base
{
public:
virtual void f(float x) { cout << "Base::f(float) " << 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 (surprise!)
// Bad : behavior depends on type of the pointer
pb->h(3.14f); // Base::h(float) 3.14 (surprise!)
pd->h(3.14f); // Derived::h(float) 3.14
}

或许叫隐藏比较贴切，因为确实隐藏了派生类的特性。