（转载）【C++拾遗】 C++函数重载、重写、重定义的区别

函数重载（overload）
函数重载是指在一个类中声明多个名称相同但参数列表不同的函数，这些的参数可能个数或顺序，类型不同，但是不能靠返回类型来判断。特征是：
（1）相同的范围（在同一个作用域中）；
（2）函数名字相同；
（3）参数不同；
（4）virtual 关键字可有可无（注：函数重载与有无virtual修饰无关）；
（5）返回值可以不同；

函数重写（也称为覆盖 override）
函数重写是指子类重新定义基类的虚函数。特征是：
（1）不在同一个作用域（分别位于派生类与基类）；
（2）函数名字相同；
（3）参数相同；
（4）基类函数必须有 virtual 关键字，不能有 static 。
（5）返回值相同，否则报错；
（6）重写函数的访问修饰符可以不同；

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

例子

#include <iostream>
using namespace std;

class Base
{
public:
    // =========================================================================
    //  子类和父类返回值参数相同，函数名相同，有/无virtual关键字
    // =========================================================================

    //  若无virtual关键字，则在子类中声明与父类同名的方法，从而覆盖了父类的方法（函数重定义）
    void a()
    {
        cout << "Base::a()" << endl;
    };

    // 若有virtual关键字，即为虚函数。由对象的类型决定调用哪个函数（多态，函数重写override）。
    virtual void b()
    {
        cout << "Base::b()" << endl;
    }

    // =========================================================================
    //  子类和父类返回值参数不同，函数名相同，有/无virtual关键字
    // =========================================================================

    // 若无virtual关键字，父类的同名成员被隐藏。
    void d(int x)
    {
        cout << "Base::d() x = " << x << endl;
    }

    // 若有virtual关键字，父类的同名成员同样被隐藏。
    virtual void e(int x)
    {
        cout << "Base::e() x = " << x << endl;
    }

    // =========================================================================
    //  子类和父类返回值参数相同，函数名相同，函数返回值不同，有/无virtual关键字
    // =========================================================================

    // 若无virtual关键字（函数重写，这种情况不属于“函数重载”范畴）
    void f()
    {
        cout << "void Base::f()" << endl;
    }

    // 若有virtual关键字 (报错）
    virtual void g()
    {
        cout << "virtual void Base::g()" << endl;
    }
};

class Derived : public Base
{
public:
    // =========================================================================
    //  子类和父类返回值参数相同，函数名相同，有/无virtual关键字
    // =========================================================================

    //  覆盖了父类同名方法（函数重写）
    void a()
    {
        cout << "Derived::a()" << endl;
    }

    // 多态
    virtual void b()
    {
        cout << "Derived::b()" << endl;
    }

    // =========================================================================
    //  子类和父类返回值参数不同，函数名相同，有/无virtual关键字
    // （注：函数重载与virtual关键字有无没有关系）
    // =========================================================================

    // 父类同名成员被隐藏
    void d(int x, int y)
    {
        cout << "Derived::d() x = " << x << " y = " << y<< endl;
    }

    // 父类同名成员被隐藏
    virtual void e(int x, int y)
    {
        cout << "Derived::e() x = " << x << " y = " << y << endl;
    }

    // =========================================================================
    //  子类和父类返回值参数相同，函数名相同，函数返回值不同，有/无virtual关键字
    // =========================================================================

    // 返回值与基类不同
    int f()
    {
        cout << "int Derived::f()" << endl;
        return 1;
    }

    //// 错误
    //virtual int g()
    //{
    //  cout << "virtual int Base::g()" << endl;
    //  return 1;
    //}
};

int main()
{
    // 用作参数
    int xx = 100;

    cout << "子类和父类返回值参数相同，函数名相同，无virtual关键字" << endl;
    Derived d;
    d.a();
    d.Base::a();    // 显示调用基类方法
    cout << "子类和父类返回值参数相同，函数名相同，有virtual关键字" << endl;
    Base* b = new Derived;
    b->b();
    cout << "子类和父类返回值参数不同，函数名相同，无virtual关键字" << endl;
    d.d(xx, xx);
    // d.d(xx); // 报错
    d.Base::d(xx); // 显示调用
    cout << "子类和父类返回值参数不同，函数名相同，有virtual关键字" << endl;
    d.e(xx, xx);
    //d.e(xx); // 报错
    d.Base::e(xx);
    cout << "子类和父类返回值参数相同，函数名相同，函数返回值不同, 无virtual关键字" << endl;
    d.f();
    d.Base::f();
}

输出：

原文地址：http://blog.csdn.net/xiejingfa/article/details/48496593