重载，覆盖，隐藏的区别

成员函数的重载，覆盖，隐藏

（1）成员函数被重载的特征：相同的类范围，函数名字相同，参数不同，virtual 关键字可有可无。

（2）覆盖指派生类的函数覆盖基类函数，特征是分别位于基类和派生类，函数名字相同，参数相同，基类函数必须有virtual关键字

（3）隐藏是指派生类的函数屏蔽了与其同名的基类函数。1，派生类的函数与基类的函数同名，但是参数不同，

不论有无virtual关键字，基类的函数将被隐藏 2，派生类的函数与基类的函数同名，并且参数也相同，

但是基类函数没有virtual 关键字。此时，基类的函数被隐藏

3种情况怎么执行：重载：看参数；隐藏：用什么就调用什么；覆盖：调用派生类 。

class A
{
public:
static int a;
static void fun()
{
cout<<"A::static void fun()"<<endl;
}


virtual void fun1()
{
cout<<"A::virtual void fun1()"<<endl;
}


virtual void fun2(int a)
{
cout<<"A::virtual void fun2(int) :"<<a<<endl;
}

  void fun3(int a)
{
cout<<"A::void fun3(int) : "<<a<<endl;
}


};
class B : public A
{
public:
int b;
void fun1()       //覆盖基类的函数
{
cout<<"B::void fun1()"<<endl;
}
void fun2(double a)    //重载基类的函数
{
cout<<"B::virtual void fun2(double) :"<<a<<endl;
}
void fun3(int a)     //隐藏基类的函数
{
cout<<"B::void fun3(int) :"<<a<<endl;
}
};
int A::a = 3;
int main()
{
A::fun();
A *a = new B();
cout<<"通过基类指针访问成员函数：－－－－－－－－－"<<endl;
a->fun1();
a->fun2(3);
a->fun2(3.14);
a->fun3(5);
B *b = new B();
cout<<"通过子类指针访问成员函数：－－－－－－－－－"<<endl;
b->fun();
b->fun1();
b->fun2(3);
b->fun2(3.14);
b->fun3(5);
return 0;
}

结果输出为：
/* 
 *::static void fun()
 通过基类指针访问成员函数：－－－－－－－－－
 B::void fun1()
 A::virtual void fun2(int) :3
 A::virtual void fun2(int) :3
 A::void fun3(int) : 5
 通过子类指针访问成员函数：－－－－－－－－－
 A::static void fun()
 B::void fun1()
 B::virtual void fun2(double) :3
 B::virtual void fun2(double) :3.14
 B::void fun3(int) :5
 * */

总结：

1，覆盖，也就是多态，基类函数名，参数与子类函数名，参数一致，基类函数为虚函数，访问的是子类的函数。

2，重载，函数名相同，参数不同，不管是不是虚函数。用什么类型的指针或引用访问的就是什么类型的函数，例如用基类指针指向子类类型，但用其访问基类和子类同名函数时，则访问的就是基类的函数，尽管调用的函数的参数与子类函数相同与基类不同，但也会转换为基类函数的参数类型，还是调用子类的函数。

3，隐藏，函数名和参数全相同，且基类函数不为虚函数。则不管基类指针指向的是基类类型还是子类类型，基类指针还是访问的是基类函数。即用什么类型指针或引用就访问什么类型的函数，与上面的相似。