本文转载自 http://www.jb51.net/article/63462.htm 、https://blog.csdn.net/ycl295644/article/details/45539193 ，更多资料可参考 https://blog.csdn.net/zx3517288/article/details/48976097

一、重载（overload）

指函数名相同，但是它的参数表列个数或顺序，类型不同。但是不能靠返回类型来判断。

相同的范围（在同一个作用域中）；
函数名字相同；
参数不同；
virtual 关键字可有可无。
返回值可以不同；

二、重写（也称为覆盖 override）

是指派生类重新定义基类的虚函数，特征是：

不在同一个作用域（分别位于派生类与基类）；
函数名字相同；
参数相同；
基类函数必须有 virtual 关键字，不能有 static 。
返回值相同（或是协变），否则报错；<—-协变这个概念我也是第一次才知道…
重写函数的访问修饰符可以不同。尽管 virtual 是 private 的，派生类中重写改写为 public,protected 也是可以的

三、重定义（也成隐藏）

不在同一个作用域（分别位于派生类与基类）；
函数名字相同；
返回值可以不同；
参数不同。此时，不论有无 virtual 关键字，基类的函数将被隐藏（注意别与重载以及覆盖混淆）。
参数相同，但是基类函数没有 virtual关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）。

重载和重写的区别：

范围区别：重写和被重写的函数在不同的类中，重载和被重载的函数在同一类中。
参数区别：重写与被重写的函数参数列表一定相同，重载和被重载的函数参数列表一定不同。
virtual的区别：重写的基类必须要有virtual修饰，重载函数和被重载函数可以被virtual修饰，也可以没有。

隐藏和重写，重载的区别：

与重载范围不同：隐藏函数和被隐藏函数在不同类中。
参数的区别：隐藏函数和被隐藏函数参数列表可以相同，也可以不同，但函数名一定同；当参数不同时，无论基类中的函数是否被virtual修饰，基类函数都是被隐藏，而不是被重写。

test

#include <iostream>
using namespace std;
class SParent
{
public:
  SParent( ){};
  SParent( const SParent &p )
  {
    cout << "parent copy construct" << endl;
  }
  int add( int a,int b )
  {
    cout << "parent int add" << endl;
    return a + b;
  }
  double add( double a,double b )
  {
    cout << "parent double add" << endl;
    return a + b;
  }
  virtual int dec( int a,int b )
  {
    cout << "parent int dec" << endl;
    return a - b;
  }
};
class SChild : public SParent
{
public:
  //using SParent::add;
  float add( float a,float b )
  {
    cout << "child float add" << endl;
    return a + b;
  }
  int dec(int a, int b)
  {
    cout << "child int dec" << endl;
    return a - b;
  }
};
int main()
{
  /* 测试重载 */
  SParent parent;
  parent.add( 3,5 );
  parent.add( (double)3,(double)5 );
  cout << endl;
  /* 测试覆盖 */
  SChild *pchild = (SChild *)new SParent();/* 基类强转为子类...危险...,用dynamic_cast转换也不行 */
  pchild->dec( 10,3 );
  SParent *pparent = new SChild();
  pparent->dec( 11,3 );
  cout << endl;
  /* 测试隐藏 */
  SChild child;
  child.add( (int)3,(int)5 );
  cout << endl;
  /* 测试函数表 */
  ((SParent *)NULL)->add( 4,6 );
  ((SChild *)NULL)->add( 4,6 );
  int a = 0;
  ((SChild *)&a)->add( 4,6 );
   cout << endl;
  /* 测试函数地址 */
  ((SParent)child).add( (int)4,(int)8 );
  child.SParent::add( 3,5 );
  return 0;
}

输出结果：

parent int add
parent double add
parent int dec
child int dec
child float add
parent int add
child float add
child float add
parent copy construct
parent int add
parent int add
按 <RETURN> 来关闭窗口...

理解

int SParent::add(int a,int b);\\重载
double SParent::add( double a,double b );\\重载
int SParent::add(int a,int b);\\被子类SChild中的float SChild::add( float a,float b )隐藏
double SParent::add( double a,double b );\\被子类SChild中的float SChild::add( float a,float b )隐藏
int SParent::dec( int a,int b )\\被子类SChild中的int SChild::dec( int a,int b )覆盖

测试

重载测试，简单易懂，略过。
覆盖测试。dec函数在基类、子类中同名同参，为虚函数，故称覆盖。

SChild pchild = (SChild )new SParent()创建的是一个基类对象，其函数表应该为

SParent::dec	…
-	-

SParent *pparent = new SChild();创建一个子类对象，其函数表应该为

SChild::dec	…
-	-

由上面的函数表可见，当发生覆盖时，子类的函数名会把基类的同名函数覆盖(这也就是为什么叫覆盖的原因吧)。这样我们可以利用一个指向子类的基类指针实现多态。但重点只有一个，就是函数表里到底指向谁(不管这个指针经过转换后是什么类型的).故输出分别为父类、子类。这是一个运行时多态。

隐藏测试

int SParent::add(int a,int b)与double SParent::add( double a,double b )都被子类SChild中的float SChild::add( float a,float b )覆盖，是因为他们同名，而且在不同的作用域中(基类、子类作用域是不同的)。child.add( (int)3,(int)5 );这行代码中，编译器在子类中查找add函数，只找到了一个(基类的add(int a,int b)会被编译根据隐藏规则略过），再根据隐式类型转换发现该函数适用。如果无法隐式转换，则编译不过。隐藏的原因：防止隐式类型转换造成错误。比如int也是可以转换成char的，假如基类有一函数add(char a,char b)，子类也有一函数add(double a,double b)。程序员想着在子类隐式把int转换为double，但编译器可能调的是基类的。这也防止了一些库或封装好的基类对程序员造成困扰。

　　像上面的代码，如果你确实需要基类的函数，可以用using SParent:add。则把基类的add函数域扩大到了子类，构成重载。

函数表测试

上面我们说到函数表，这个是在编译时定好的，程序运行时加载到内存中。这意味着我们可以直接通过地址去调用函数。所以((SChild *)NULL)->add( 4,6 );这种代码也是能运行通过的。网上还有人通过计算直接取到了函数表的地址直接调用了。但这种代码不安全不规范不说，还有个更大的问题。当成员函数里需要调用成员变量时，通过这种假的对象指针肯定找不到成员变量表，直接访问了非法内存。

函数地址测试

有了隐藏、覆盖，哪么我们要怎么调用被隐藏、覆盖的函数呢。下面有两种方法：

((SParent)child).add( (int)4,(int)8 );
child.SParent::add( 3,5 );

第一种是比较低效的方法。事实上它是通过拷贝构造函数生成一个临时的基类变量去调用基类的add函数。
第二种通过::指定域去访问。这种方法是编译器根据域直接找到了基类的函数地址，跟函数表没有多大关系。