重写、重载和重定义的区别

重写（override）

首先，重写是指派生类的方法覆盖基类的方法，要求方法名、方法的参数都相同。重写是C++中实现多态这个特性基础。重写又称为覆盖，是指派生类函数覆盖基类函数，与重定义不同，重写要求被重写的基类函数为虚函数。
例如下面的代码：

class Base{
public:
    virtual int Total(int unit_price, int num) = 0;
};
class Derived :public Base{
public:
    virtual int Total(int unit_price, int num)
    {
        cout << "test" << endl;
        return 0;
    }
};
class Child :public Derived{
public:
    int Total(int unit_price, int num)
    {
        //
        return unit_price*num;
    }
};

总结一下，重写是指派生类重新定义了基类的虚函数，基类函数必须有virtual关键字修饰，不能有static关键字；返回值类型必须是相同的，或者是协变的；此外重写函数的访问修饰符可以不同。
注意：一般重写要求函数具有完全相同的入参，否则就会提示错误，而这个规则对于协变而言则有所放松。覆盖的返回值不区分基类或者派生类，如下代码：

class Base{
public:
    virtual int Total(int unit_price, int num)
    {
        cout << "Base" << endl;
        return 0;
    }
};
class Derived :public Base{
public:
    virtual int Total(int unit_price, int num)
    {
        cout << "test" << endl;
        return 1;
    }
};
//协变
class Father{
public:
    virtual const Base& getClass() = 0;
};
class Child{
    virtual const Derived& getClass()
    {
        Derived ret;
        return ret;
    }
};

在上面协变的例子中，要求Base和Derived两个类必须在使用前被完整的定义。
协变返回类型的优势在于，若是我们使用Father，就能获得一个抽象的Base，如果我们正在处理Child，就会获得一个Derived。协变的返回机制将我们从这样一种处境中解脱出来：不得不使用易于出错的转换操作来“重新”提供类型信息，而这种信息是一开始就不应该丢掉的。

重载（overload）

然后是重载（overload），重载是应用于相同作用域之内的同名函数，由于参数列表不同而产生的不同的实现方法。此处提到的作用域有：全局作用域、局部作用域以及类作用域，当在同一个作用域内的时候同名的函数或者称之为方法，由于参数列表的不同，而获得的不同的函数。

int Sum(int a, int b);
int Sum(int a, int b, int c);
int Sum(float a, float b);

重载是一种语言特性，是一种语法规则，与多态无关，与面向对象无关。

重定义

重定义则是经常出现在基类和派生类之间，归结起来有如下的特点：
1）不在同一个作用域，主要是指类作用域，分别位于基类和派生类之中；
2）函数名称相同，但是返回值可以不同；
3）参数不同时，无论有没有virtual关键字，基类的函数都会被隐藏；参数相同时，但是基类函数没有关键字virtual，此时基类函数被隐藏。
例如：

class Base{
public:
    virtual double Total(double a, double b)
    {
        return a + b;
    }
    void Print()
    {
        cout << "Base" << endl;
    }
    int Sum(int a, int b);

private:
    //
};
class Derived :public Base{
public:
    virtual double Total(double a, double b, double c)
    {
        return a + b + c;
    }
    void Print()
    {
        cout << "Derived" << endl;
    }
    int Sum(int a, int b, int c);
};

在运行Derived的实例的时候可以很容易的发现，基类中Sum函数被隐藏了。因此重定义又称为隐藏，是指派生类的函数屏蔽了与其同名的基类函数。

int _tmain(int argc, _TCHAR* argv[])
{
    Derived test;
    test.Print();
    Derived test_b;
    Base *p;
    p = new Derived;
    p->Print();
    Base *p_2;
    p_2 = &test_b;
    p_2->Print();
    delete p;
    system("pause");
    return 0;
}

例如上面的类，我们在如上调用的时候得到了下面的输出：