重载（overload）

C++允许函数重载，即在同一作用域内可以定义多个同名的函数，只需要函数的“签名”不同就行，这里的“签名”包括参数和函数的类型，但是不包括返回值的类型：

#include <iostream>

class Foo {
public :
    void func() {
        std::cout << "func()" << std::endl;
    }

    void func(int n) {
        std::cout << "func(int)" << std::endl;
    }

    void func(int n) const {
        std::cout << "func(int) const" << std::endl;
    }
};

int main(int argc, const char* argv[]) {
    Foo foo;
    foo.func();                 //调用func()
    foo.func(10);               //调用func(int)
    const Foo& constFoo = foo;
    constFoo.func(10);          //调用func(int) const

    return 0;
}

覆盖（override）

覆盖就是派生类中重新实现基类中的虚函数，要求参数和函数类型完全一致，返回值一般也需要完全一致，只有一种情况例外，那就是返回指针和引用类型时，如果指针和引用类型也有继承关系，那么也是可以正确覆盖的：

#include <iostream>

class Parent {};
class Child : public Parent {};

class Base {
public :
    virtual Parent *func() {
        std::cout << "Base::func" << std::endl;
        return new Parent;
    }
};

class Derived : public Base {
public:
    virtual Child *func() override {
        std::cout << "Derived::func" << std::endl;
        return new Child;
    }
};

int main(int argc, const char* argv[]) {
    Derived derived;
    Base &base = derived;
    Parent *pParent = base.func();  //调用Derived::func
    delete pParent;

    return 0;
}

隐藏（hide）

隐藏就是派生类中的函数和基类中函数重名了，这时基类中的所有同名函数都将被隐藏无法直接通过派生类对象调用：

#include <iostream>

class Base {
public :
    void func() {
        std::cout << "Base::func" << std::endl;
    }

    void func(int n) {
        std::cout << "Base::func(int)" << std::endl;
    }

    void func(int n, int m) {
        std::cout << "virtual Base::func(int, int)" << std::endl;
    }
};

class Derived : public Base {
public:
    void func() {
        std::cout << "Derived::func" << std::endl;
    }
};

int main(int argc, const char* argv[]) {
    Derived derived;
    derived.func();         //调用Derived::func
    derived.func(10);       //Base::func(int)被隐藏，编译出错
    derived.func(10, 10);   //virtual Base::func(int, int)被隐藏，编译出错

    return 0;
}