C++ 覆盖 重载 隐藏 override overload hidden

直接贴个链接好了，下面的别看了。很有可能是错的！
http://cboard.cprogramming.com/cplusplus-programming/146473-overloading-overriding-hiding-help.html

• 一般重载是指函数名相同，但是参数类型不同，与函数的返回值类型无关。重载函数发生在非成员函数中。子类和基类之间不存在重载，除非在子类中显示的加入基类的同名函数。

• 覆盖是指子类函数将基类虚函数覆盖，此时参数相同，且基类须有virtual修饰。覆盖的意思，就是基类的同名函数，在派生类内，将变得无法直接调用，但可以间接调用。

———————————错误开始—————————————-
~隐藏是指子类中函数与基类中函数名称相同，若~
~1. 参数类型相同，但基类函数之前没有virtual修饰，基类函数被隐藏~
~2. 参数类型不同，无论基类函数之前有无virtual修饰，基类函数都被隐藏~

———————————错误结束—————————————–

其实没有隐藏规则，C++中规定“只有在通过基类指针或引用间接指向派生类子类型时多态性才会起作用。”注意动态绑定和静态绑定就好了。

首先，函数名是相同的。
重载发生在同一个类中。覆盖发生在基类和子类中。
其次，看参数。
如果参数名相同，且有virtual修饰，为覆盖
如果参数名不同，不管virtual修饰，为覆盖，重定义基类的成员函数

三段程序，覆盖和隐藏先占坑

---

#include <iostream>

using namespace std;

class myclass
{
public:
    virtual void print() const
    {
        cout << "a const" << endl;
    }
    virtual void print()
    {
        cout << "a" << endl;
    }
private:

};

class myclass1 :public myclass
{
public:
    void print() const
    {
        cout << "b const" << endl;
    }
    void print()
    {
        cout << "b" << endl;
    }
private:

};

void g(const myclass* a)
{
    a->print();
}
int main()
{
    myclass *a = new myclass1;
    a->print();
    g(a);
    myclass a1;
    a1.print();
    return 0;
}

---

#include <iostream>
using namespace std;
class Base
{
public:
    virtual void print() const 
    {
        cout << "Base::print() const" << endl;
    }
    void print()
    {
        cout << "Base::print()" << endl;
    }
};

class Test : public Base
{
public:
    void print();
    void print() const;
};

void Test::print()
{
    cout << "Test::print()" << endl;
}

void Test::print() const
{
    cout << "Test::print() const" << endl;
}

class C:public Test
{
public:
    void print()
    {
        cout << "C" << endl;
    }
    void print() const
    {
        cout << "C::print() const" << endl;
    }

private:

};

void main()
{
    Base* pChild = new Test();
    pChild->print();
    Test* p0 = new Test();
    p0->print();
    const Base *p1 = new Test();
    p1->print();
}

---

#include<iostream>
#include<string>
using namespace std;
class A
{

public:
    A(){}
    void f(){ cout << 'a' << endl; }
    virtual void g(){ cout << "invoke aaa" << endl; }
};
class B :public A
{
public:
    B(){}
    virtual void g(){ cout << "invoke bbb" << endl; }
    void f(){ cout << 'b' << endl; }
};
class C :public B
{
public:
};

int main()
{
    A* a = new B;
    A* b = new A;
    B* c = new B;
    C* d = new C;
    A* e = new C;
    a->f();
    b->f();
    c->f();
    d->f();
    e->f();
    cout << "-------------------------" << endl;
    a->g();
    b->g();
    c->g();
    return 0；
}