c++子父类的函数隐藏和覆盖的区别

[likeyuanyuan]

在看《高质量c/c++》中看到了函数的隐藏和覆盖是这么说的：

覆盖的是指子类函数覆盖基类函数
在不同的类内（分别位于子类和父类）。
同名同参。
基类的函数名前必须有virtual关键字。
隐藏指派生类的函数隐藏了基类的同名函数
如果派生类函数与基类函数同名，但参数不同，无论基类函数前是否有virtual修饰，基类函数被隐.
如果派生类函数与基类函数同名，参数也相同，但是基类函数前无virtual修饰，基类函数被隐藏。

class Base
{
public:
    virtual	void f(float x){ cout << "Base::f(float) " << x << endl; }
    void g(float x){ cout << "Base::g(float) " << x << endl; }
    void h(float x){ cout << "Base::h(float) " << x << endl; }
};
class Derived : public Base
{
public:
    virtual	void f(float x){ cout << "Derived::f(float) " << x << endl; }
    void g(int x)  { cout << "Derived::g(int) " << x << endl; }
    void h(float x){ cout << "Derived::h(float) " << x << endl; }
};

Derived::f(float x)函数覆盖了基类Base：：f(float x)函数。子父类同名同参，父类有virtual关键字
Derived::g(int x) 函数隐藏了基类Base：：g(float x)函数。同名不同参，无论有无virtual修饰
Derived::f(float x)函数隐藏了基类Base：：f(float x)函数。同名同参，且基类无virtulal修饰

[likeyuanyuan]

问题是：
我现在的理解，隐藏和覆盖的区别在哪？除了语义上的，能不能举个实用的例子，说说隐藏和覆盖的区别

[_Minzey]

覆盖是指派生类函数覆盖基类函数，特征是：
（1）不同的范围（分别位于派生类与基类）；
（2）函数名字相同；
（3）参数相同；
（4）基类函数必须有virtual 关键字。

“隐藏”是指派生类的函数屏蔽了与其同名的基类函数，规则如下：
（1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆）。
（2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual 关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）
隐藏后， 即在子类中看不到父类的函数。

[flylee]

覆盖应该这么理解，在多态的时候，根据实际的对象类型，选择合适的实现，当持有子类实例时，父类的成员实现是不可见的
比如virtual void base::f()和void derived::f()，若实际的对象是derived的实例，则调用的是derived::f()。

而隐藏应该从名字空间的角度理解，子类不会自动引入父类的名字空间
例如void base::f()，void base::f(int)，和void derived::f()，这个三个函数不在同一名字空间，父类的两个成员被隐藏，不会发生重载

[likeyuanyuan]

不要那些概念性的，需要那些对概念自己理解或者对概念更加通俗的解释，
应该看对照概念去理解，那没问题。
谢谢楼上
谢谢3楼，3楼的解释，我明天好好理解下，先睡了，好困。
也谢谢2楼，2楼的太概念了，

[庄鱼]

覆盖是指继承类必须要有实现，否则便已无法通过的函数定义式：
class A{
public:
virtual void f();
void f(int);
virtual void f(char*);};
class B:public A{
public:
void f();//------- 必须定义(有函数实现)
};
A *p = new B(); p->f(); //---覆盖 正确
p->f(1); //------------ 隐藏，正确
p->f("1"); //----------- 错误 缺实现，//应该为覆盖的，但采用隐藏式调用

[rainkin1993]

我可以给你说说我的理解
我认为隐藏和覆盖的区别主要体现在 多态上
举个例子

#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;}
};

int main()
{
A * a = new B;
A * b = new A;
B * c = new B;
a->f();
b->f();
c->f();
cout<<"-------------------------"<<endl;
a->g();
b->g();
c->g();
}
结果是
a
a
b
invoke bbb
invoke aaa
invoke bbb

我想说的是 如果是隐藏的话 当你通过指针调用这个函数的时候,调用根据的是指针的类型
如果是覆盖的话 当你通过指针调用这个函数的时候,根据的是指针指向的类型

这就是我的理解 希望对你有用