C++中“重载“、“ 覆盖”、“隐藏”的区别分析

1.重载

(1).重载（overload）:同一可访问区内被声明的几个具有不同参数列表（参数类型，个数，顺序不同）的同名函数。
(2).示例代码

class A
{
    void sum(int i,int j);    //<1>
    void sum(int arr[],int n);//<2>
    int  sum(int i);          //<3>
    //<1>,<2>构成重载,<1>,<3>不构成重载
};

2.隐藏

(1).隐藏（hidden）是指派生类（子类）的函数屏蔽了与其同名的基类（父类）函数。
(2).只要子类中有同名函数，则不管参数列表是否相同，父类函数都会被隐藏。
(3).示例代码

#include <iostream>
#include <stdlib.h>
using namespace std;
class A
{
public :
    void func1(int i)
    {
        cout<<"A::func1"<<""<<i<<endl;
    };
};

class B:public A
{
public:
     void func1(int i,int j)
    {
        cout<<"B::func1"<<"//"<<i<<"//"<<j<<endl;
    };

};
int main(void)
{
    B b;
    b.func1(2,3);//调用B类中的函数func1(int i,int j)
    b.func1(1);  //出错，父类中func1(int i)被隐藏
    system("pause"); 
    return 0;
}

3.覆盖

(1).覆盖（override），或者叫重写，是指 派生类中存在重新定义的函数。其参数名，返回值类型，所有都必须同基类中被重写的函数一致。只有函数体不同，派生类调用时会调用派生类的重写函数，不会调用被重写函数。
(2).基类中被覆盖的函数必须有virtual关键字修饰。
(3).示例代码

#include <iostream>
#include <stdlib.h>
using namespace std;
class A
{
public :
    virtual void func1(int i)//虚函数
    {
        cout<<"A::func1"<<""<<i<<endl;
    };
};

class B:public A
{
public:
    void func1(int i)
    {
        cout<<"AB::func1"<<""<<i<<endl;
    };

};
int main(void)
{
    A a;
    B b;
    A *p=&a;
    p->func1(2);
    p=&b;        //父类的对象指向子类的实例
    p->func1(2); //通过父类指针调用子类的成员函数
    system("pause");
    return 0;
}

重载与覆盖的区别

(1).范围区别：覆盖和被覆盖的函数在不同的类中，重载与被重载的函数在同一类中。
(2).参数区别：覆盖与被覆盖的函数参数列表一定相同，重载和被重载的函数参数列表一定不同。
(3). virtual的区别：覆盖的基类必须有关键字virtual修饰，重载函数和被重载函数可以被virtual修饰，也可以没有。

隐藏与覆盖、重载的区别

(1).与重载的范围不同：隐藏函数和被隐藏函数在不同类中。
(2).参数的区别：隐藏函数与被隐藏函数参数列表可以相同，也可以不同，但函数名一定不同；当参数不同时，无论基类中的函数是否被virtual修饰，基类函数都是被隐藏，而不是被覆盖。

代码练习

#include <iostream>
#include <stdlib.h>
using namespace std;
class A
{
public :
    //重载
    void func1(int i)
    {
        cout<<"A::func1"<<"//"<<i<<endl;
    };
    void func2(int i,int j)
    {
        cout<<"A::func2"<<"//"<<i<<"//"<<j<<endl;
    }
    virtual void func3(int i)
    {
        cout<<"A::func3"<<"//"<<i<<endl;
    }
};

class B:public A
{
public:
    //隐藏
    void func1(double i)
    {
        cout<<"B::func1"<<""<<i<<endl;
    };
    //覆盖
    void func3(int i)
    {
        cout<<"B::func3(int)"<<"//"<<i<<endl;
    }
    //隐藏
    void func3(double i)
    {
        cout<<"B::func3(double)"<<"//"<<i<<endl;
    }

};
int main(void)
{
    A a;
    B b;
    A *pa=&b;
    B *pb=&b;
    //重载
    a.func1(1);
    a.func2(1,2);
    //覆盖
    pa->func3(3);
    //隐藏 调用B的函数
    b.func3(10);
    //隐藏 调用B的函数
    pb->func3(2.1);

    system("pause");
    return 0;
}
![运行结果](http://img.blog.csdn.net/20161004163653830)