作为初学者，本文只从语法和简单的使用角度对overload、overwrite、override进行了区分，不曾涉及原理，记录下来以供查阅。

1.verload(重载)

1.1 基本要求：

c++中的重载需要满足以下几个要求：

• 相同的作用域
• 函数名相同，参数列表不同，与返回值类型无关

例如：

void Fun()
{

}
void Fun(int n)
{

}
int Fun()       //只是返回类型不同，不能构成重载
{

}

注意：同名的函数必须在相同的作用域内才构成重载。

1.2 类中成员函数

类中的普通成员函数构成重载要满足上面的基本要求，另外：

• 成员函数的名称，参数列表相同时，non-const成员函数与const成员函数可以构成重载；
• 成员函数的名称，参数列表不同时，non-const成员函数与const成员函数可以构成重载；
• 成员函数的名称，参数列表相同时，non-static成员函数与static成员函数不能构成重载；
• 成员函数的名称，参数列表不同时，non-static成员函数与static成员函数可以构成重载

例如：

class Test
{
public:
    void Fun();
    void Fun() const;
    static void Fun(int n);
};

void Test::Fun() 
{
    cout << "Test::Fun() ..." << endl;
}
void Test::Fun() const
{
    cout << "Test::Fun() const ..." << endl;
}
/*
void Test::Fun()
{
    cout << "static Fun() ..." << endl;
}
*/
void Test::Fun(int n)
{
    cout << "static Fun(int n) ..." << endl;
}

注意：const成员函数在类中声明时带const关键字，在类外定义时也要加const关键字；static成员函数在类中声明时带const关键字，在类外定义时则不需要加static关键字。

2.override(覆盖)

override和overwrite都是发生在基类与派生类函数之间，override需要满足以下几个要求：

• 不同的作用域，基类与派生类
• 虚函数，基类的成员函数带virtual关键字
• 基类成员函数与派生类成员函数名称相同，参数列表也相同

例如：

class Base
{
public:
    virtual void Fun();
};

void Base::Fun()
{
    cout << "Base::Fun ..." << endl;
}
class Derived :public Base
{
public:
    void Fun();
};
void Derived::Fun()
{
    cout << "Derived::Fun ..." << endl;
}

int main()
{
    Base* pb = new Base;
    Derived d;
    pb = &d;//基类指针指向派生类对象
    pb->Fun(); //调用派生类的函数实现多态 
    pb->Base::Fun();

    return 0;
}

在这个例子中要注意的是，基类的virtual void Fun();与派生类的void Fun();形成多态,所以可以通过基类指针访问派生类的函数

3.overwrite(重写)

overwrite需要满足以下几个要求：

• 不同的作用域，基类与派生类
• 基类成员函数不带virtual关键字，基类成员函数与派生类成员函数名称相同，参数列表相同与不相同都可以
• 基类成员函数带virtual关键字，但基类成员函数与派生类成员函数名称相同，参数列表不相同

例如：基类成员函数带virtual关键字，但基类成员函数与派生类成员函数名称相同，参数列表不相同时：

class Base
{
public:
    virtual void Fun();
};

void Base::Fun()
{
    cout << "Base::Fun ..." << endl;
}
class Derived :public Base
{
public:
    void Fun(int n);
};
void Derived::Fun(int n)
{
    cout << "Derived::Fun ..." << endl;
}
int main()
{
    Base* pb = new Base;
    Derived d;
    pb = &d;
    pb->Fun();
    //pb->Fun(2);   Error,没有形成多态，不能调用派生类的函数
    
    d.Fun(3);
    //d.Fun();  //Error,基类中的Fun()被派生类重写，隐藏起来
    d.Base::Fun();//通过作用域运算符调用基类函数

    return 0;
}

在这个例子中要注意的是，基类的virtual void Fun();与派生类的void Fun(int n);没有形成多态,所以不能通过基类指针访问派生类的函数

再例如：基类成员函数不带virtual关键字，基类成员函数与派生类成员函数名称相同，参数列表相同与不相同时

class Base
{
public:
    void Fun();
};

void Base::Fun()
{
    cout << "Base::Fun ..." << endl;
}
class Derived :public Base
{
public:
    void Fun(int n);
};
void Derived::Fun(int n)
{
    cout << "Derived::Fun ..." << endl;
}

int main()
{
    Derived d;

    d.Fun(3);
    //d.Fun();  //Error,基类中的Fun()被派生类重写，隐藏起来
    d.Base::Fun();

    return 0;
}

class Base
{
public:
    void Fun();
};

void Base::Fun()
{
    cout << "Base::Fun ..." << endl;
}
class Derived :public Base
{
public:
    void Fun();
};
void Derived::Fun()
{
    cout << "Derived::Fun ..." << endl;
}

int main()
{
    Derived d;

    d.Fun();//调用派生类的函数，基类函数被重写隐藏
    d.Base::Fun();

    return 0;
}

通过对overwrite的3个例子实现，发现overwrite会将基类的函数隐藏起来，派生类对这个函数进行重写，通过派生类对象不能直接调用该函数；基类指针指向派生类对象时，只能调用基类的函数，不能调用派生类函数