重载和覆盖的区别

重载是让同名的方法根据不同的数据类型可以处理和返回不同类型的数据。而覆盖则与作用域有关了，在子类中与父类同名的方法，在子类中父类的方法就不能被调用，可以说被屏蔽了。

重载是让同一方法名的方法可以处理和返回不同类型的数据,而覆盖是在子类中改写父类的方法

重载与覆盖的区别

1、方法的覆盖是子类和父类之间的关系，是垂直关系；方法的重载是同一个类中方法之间的关系，是水平关系。

2、覆盖只能由一个方法，或只能由一对方法产生关系；方法的重载是多个方法之间的关系。

3、覆盖要求参数列表相同；重载要求参数列表不同。

4、覆盖关系中，调用那个方法体，是根据对象的类型（对象对应存储空间类型）来决定；重载关系，是根据调用时的实参表与形参表来选择方法体的。

相同点:被覆盖(重载)的函数的函数名必须是一样的;

不同点:覆盖的函数的函数参数表必须和被覆盖的函数的参数表一样,重载的函数的函数参数表必须和被重载的函数的参数表不一样.

要值得提到的是,C和C++对函数的解析,C一般都把函数名解析成类似__FUNCTION__,而C++却是要加一个参数表的,类似于:__FUNCTION_VAR__,这就是C++实现多态的机制.

extern "C" 的作用就是把C语言的函数名解析成C++的函数名,否则C++编译器是识别不了这些符号的.

以上几条都是从百度知道搜索得到。

重载与覆盖的区别

经常看到C++的一些初学者对于重载、覆盖、多态与函数隐藏的模糊理解。在这里写一点自己的见解，希望能够C++初学者解惑。

要弄清楚重载、覆盖、多态与函数隐藏之间的复杂且微妙关系之前，我们首先要来回顾一下重载覆盖等基本概念。

⑴首先，我们来看一个非常简单的例子，理解一下什么叫函数隐藏hide。

#include <iostream>

using namespace std;

class Base

{

public:

void fun() { cout << "Base::fun()" << endl; }

};

class Derive : public Base

{

public:

void fun(int i) { cout << "Derive::fun()" << endl; }

};

int main()

{

Derive d;

//下面一句错误，故屏蔽掉

//d.fun();error C2660: ''''fun'''' : function does not take 0 parameters

d.fun(1);

Derive *pd =new Derive();

//下面一句错误，故屏蔽掉

//pd->fun();error C2660: ''''fun'''' : function does not take 0
parameters

pd->fun(1);

delete pd;

return 0;

}

在这个例子中，函数不是重载overload，也不是覆盖override，而是隐藏hide。

接下来的5个例子具体说明一下什么叫隐藏

例1

#include <iostream>

using namespace std;

class Basic

{

public:

void fun(){cout << "Base::fun()" << endl;}//overload

void fun(int i){cout << "Base::fun(int i)" << endl;}//overload

};

class Derive :public Basic

{

public:

void fun2(){cout << "Derive::fun2()" << endl;}

};

int main()

{

Derive d;

d.fun();//正确，派生类没有与基类同名函数声明，则基类中的所有同名重载函数都会作为候选函数。

d.fun(1);//正确，派生类没有与基类同名函数声明，则基类中的所有同名重载函数都会作为候选函数。

return 0;

}

例2

#include <iostream>

using namespace std;

class Basic{

public:

void fun(){cout << "Base::fun()" << endl;}//overload

void fun(int i){cout << "Base::fun(int i)" << endl;}//overload

};

class Derive :public Basic{

public:

//新的函数版本,基类所有的重载版本都被屏蔽,在这里,我们称之为函数隐藏hide

//派生类中有基类的同名函数的声明，则基类中的同名函数不会作为候选函数，即使基类有不同的参数表的多个版本的重载函数。

void fun(int i,int j){cout << "Derive::fun(int i,int j)" << endl;}

void fun2(){cout << "Derive::fun2()" << endl;}

};

int main()

{

Derive d;

d.fun(1,2);

//下面一句错误，故屏蔽掉

//d.fun();error C2660: ''''fun'''' : function does not take 0 parameters

return 0;

}

例3

#include <iostream>

using namespace std;

class Basic{

public:

void fun(){cout << "Base::fun()" << endl;}//overload

void fun(int i){cout << "Base::fun(int i)" << endl;}//overload

};

class Derive :public Basic{

public:

//覆盖override基类的其中一个函数版本,同样基类所有的重载版本都被隐藏hide

//派生类中有基类的同名函数的声明，则基类中的同名函数不会作为候选函数，即使基类有不同的参数表的多个版本的重载函数。

void fun(){cout << "Derive::fun()" << endl;}

void fun2(){cout << "Derive::fun2()" << endl;}

};

int main()

{

Derive d;

d.fun();

//下面一句错误，故屏蔽掉

//d.fun(1);error C2660: ''''fun'''' : function does not take 1
parameters

return 0;

}

例4

#include <iostream>

using namespace std;

class Basic{

public:

void fun(){cout << "Base::fun()" << endl;}//overload

void fun(int i){cout << "Base::fun(int i)" << endl;}//overload

};

class Derive :public Basic{

public:

using Basic::fun;

void fun(){cout << "Derive::fun()" << endl;}

void fun2(){cout << "Derive::fun2()" << endl;}

};

int main()

{

Derive d;

d.fun();//正确

d.fun(1);//正确

return 0;

}

例5

#include <iostream>

using namespace std;

class Basic{

public:

void fun(){cout << "Base::fun()" << endl;}//overload

void fun(int i){cout << "Base::fun(int i)" << endl;}//overload

};

class Derive :public Basic{

public:

using Basic::fun;

void fun(int i,int j){cout << "Derive::fun(int i,int j)" << endl;}

void fun2(){cout << "Derive::fun2()" << endl;}

};

int main()

{

Derive d;

d.fun();//正确

d.fun(1);//正确

d.fun(1,2);//正确

return 0;

}

例7-1

#include <iostream>

using namespace std;

class Base{

public:

virtual void fun(int i){ cout <<"Base::fun(int i)"<< endl; }

};

class Derive : public Base

{

};

int main()

{

Base *pb = new Derive();

pb->fun(1);//Base::fun(int i)

delete pb;

return 0;

}

例7-2

#include <iostream>

using namespace std;

class Base{

public:

virtual void fun(int i){ cout <<"Base::fun(int i)"<<
endl; }

};

class Derive : public Base{

public:

void fun(double d){ cout <<"Derive::fun(double d)"<< endl; }

};

int main()

{

Base *pb = new Derive();

pb->fun(1);//Base::fun(int i)

pb->fun((double)0.01);//Base::fun(int
i)

delete pb;

return 0;

}

例8-1

#include <iostream>

using namespace std;

class Base{

public:

virtual void fun(int i){ cout <<"Base::fun(int i)"<< endl; }

};

class Derive : public Base{

public:

void fun(int i){ cout <<"Derive::fun(int i)"<< endl; }

};

int main()

{

Base *pb = new Derive();

pb->fun(1);//Derive::fun(int i)

delete pb;

return 0;

}

例8-2

#include <iostream>

using namespace std;

class Base{

public:

virtual void fun(int i){ cout <<"Base::fun(int i)"<<
endl; }

};

class Derive : public Base{

public:

void fun(int i){ cout <<"Derive::fun(int i)"<< endl; }

void fun(double d){ cout <<"Derive::fun(double d)"<<
endl; }

};

int main()

{

Base *pb = new Derive();

pb->fun(1);//Derive::fun(int i)

pb->fun((double)0.01);//Derive::fun(int
i)

delete pb;

return 0;

}

例9

#include <iostream>

using namespace std;

class Base{

public:

virtual void fun(int i){ cout <<"Base::fun(int i)"<<
endl; }

};

class Derive : public Base{

public:

void fun(int i){ cout <<"Derive::fun(int i)"<< endl; }

void fun(char c){ cout
<<"Derive::fun(char c)"<< endl; }

void fun(double d){ cout
<<"Derive::fun(double d)"<< endl; }

};

int main()

{

Base *pb = new Derive();

pb->fun(1);//Derive::fun(int i)

pb->fun('a');//Derive::fun(int
i)

pb->fun((double)0.01);//Derive::fun(int
i)

Derive *pd =new Derive();

pd->fun(1);//Derive::fun(int i)

//overload

pd->fun('a');//Derive::fun(char
c)

//overload

pd->fun(0.01);//Derive::fun(double
d)

delete pb;

delete pd;

return 0;

}

例7-1和例8-1很好理解，我把这两个例子放在这里，是让大家作一个比较摆了，也是为了帮助大家更好的理解：

例7-1中，派生类没有覆盖基类的虚函数，此时派生类的vtable中的函数指针指向的地址就是基类的虚函数地址。

例8-1中，派生类覆盖了基类的虚函数，此时派生类的vtable中的函数指针指向的地址就是派生类自己的重写的虚函数地址。

在例7-2和8-2看起来有点怪怪，其实，你按照上面的原则对比一下，答案也是明朗的：

例7-2中，我们为派生类重载了一个函数版本：void fun(double d) 其实，这只是一个障眼法。我们具体来分析一下，基类共有几个函数，派生类共有几个函数：

[align=left]类型[/align]	[align=left]基类[/align]	[align=left]派生类[/align]
[align=left]Vtable部分[/align]	[align=left]void fun(int i)[/align]	[align=left]指向基类版的虚函数void fun(int i)[/align]
[align=left]静态部分[/align]	[align=left] [/align]	[align=left]void fun(double d)[/align]

我们再来分析一下以下三句代码

Base *pb = new Derive();

pb->fun(1);//Base::fun(int i)

pb->fun((double)0.01);//Base::fun(int i)

这第一句是关键，基类指针指向派生类的对象，我们知道这是多态调用；接下来第二句，运行时基类指针根据运行时对象的类型，发现是派生类对象，所以首先到派生类的vtable中去查找派生类的虚函数版本，发现派生类没有覆盖基类的虚函数，派生类的vtable只是作了一个指向基类虚函数地址的一个指向，所以理所当然地去调用基类版本的虚函数。最后一句，程序运行仍然埋头去找派生类的vtable，发现根本没有这个版本的虚函数，只好回头调用自己的仅有一个虚函数。

这里还值得一提的是：如果此时基类有多个虚函数，此时程序编绎时会提示”调用不明确”。示例如下

#include <iostream>

using namespace std;

class Base{

public:

virtual void fun(int i){ cout <<"Base::fun(int i)"<< endl; }

virtual void fun(char c){ cout <<"Base::fun(char c)"<< endl; }

};

class Derive : public Base{

public:

void fun(double d){ cout <<"Derive::fun(double d)"<< endl; }

};

int main()

{

Base *pb = new Derive();

pb->fun(0.01);//error C2668: 'fun' : ambiguous call to overloaded function

delete pb;

return 0;

}

好了，我们再来分析一下例8-2。

n 例8-2中，我们也为派生类重载了一个函数版本：void fun(double d) ，同时覆盖了基类的虚函数，我们再来具体来分析一下，基类共有几个函数，派生类共有几个函数：

[align=left]类型[/align]	[align=left]基类[/align]	[align=left]派生类[/align]
[align=left]Vtable部分[/align]	[align=left]void fun(int i)[/align]	[align=left]void fun(int i)[/align]
[align=left]静态部分[/align]	[align=left] [/align]	[align=left]void fun(double d)[/align]

从表中我们可以看到，派生类的vtable中函数指针指向的是自己的重写的虚函数地址。

我们再来分析一下以下三句代码

Base *pb = new Derive();

pb->fun(1);//Derive::fun(int i)

pb->fun((double)0.01);//Derive::fun(int i)

第一句不必多说了，第二句，理所当然调用派生类的虚函数版本，第三句，嘿，感觉又怪怪的，其实呀，C++程序很笨的了，在运行时，埋头闯进派生类的vtable表中（虚函数表virtual function table），只眼一看，靠，竞然没有想要的版本，真是想不通，基类指针为什么不四处转转再找找呢?呵呵，原来是眼力有限，基类年纪这么老了，想必肯定是老花了，它那双眼睛看得到的仅是自己的非Vtable部分(即静态部分)和自己要管理的Vtable部分，派生类的void fun(double d)那么远，看不到呀!再说了，派生类什么都要管，难道派生类没有自己的一点权力吗?哎，不吵了，各自管自己的吧^_^

唉!你是不是要叹气了，基类指针能进行多态调用，但是始终不能进行派生类的重载调用啊(参考例6)~~~

再来看看例9，本例的效果同例6，异曲同工

[align=left]小结：[/align]
[align=left] [/align]
[align=left] 重载overload是根据函数的参数列表来选择要调用的函数版本，而覆盖是根据运行时对象的实际类型来选择要调用的虚virtual函数版本，覆盖的实现是通过派生类对基类的虚virtual函数进行覆盖override来实现的，若派生类没有对基类的虚virtual函数进行覆盖override的话，则派生类会自动继承基类的虚virtual函数版本，此时无论基类指针指向的对象是基类型还是派生类型，都会调用基类版本的虚virtual函数；如果派生类对基类的虚virtual函数进行覆盖override的话，则会在运行时根据对象的实际类型来选择要调用的虚virtual函数版本，例如基类指针指向的对象类型为派生类型，则会调用派生类的虚virtual函数版本，从而实现多态。[/align]
[align=left] [/align]
[align=left] 使用多态的本意是要我们在基类中声明函数为virtual，并且是要在派生类中覆盖override基类的虚virtual函数版本，注意，此时的函数原型与基类保持一致，即同名同参数类型；如果你在派生类中新添加函数版本，你不能通过基类指针动态调用派生类的新的函数版本，这个新的函数版本只作为派生类的一个重载版本。还是同一句话，重载只有在当前类中有效，不管你是在基类重载的，还是在派生类中重载的，两者互不牵连。如果明白这一点的话，在例6、例9中，我们也会对其的输出结果顺利地理解。[/align]
[align=left] [/align]
[align=left] 重载是静态联编的，覆盖是动态联编的。进一步解释，重载与指针实际指向的对象类型无关，覆盖与指针实际指向的对象类型相关。若基类的指针调用派生类的重载版本，C++编绎认为是非法的，C++编绎器只认为基类指针只能调用基类的重载版本，重载只在当前类的名字空间作用域内有效，继承会失去重载的特性，当然，若此时的基类指针调用的是一个虚virtual函数，那么它还会进行动态选择基类的虚virtual函数版本还是派生类的虚virtual函数版本来进行具体的操作，这是通过基类指针实际指向的对象类型来做决定的，所以说重载与指针实际指向的对象类型无关，多态与指针实际指向的对象类型相关。 [/align]
[align=left] [/align]
[align=left] 最后阐明一点，虚virtual函数同样可以进行重载，但是重载只能是在当前自己名字空间作用域内有效(请再次参考例6)。[/align]
[align=left] [/align]
[align=left]重载overload的特征：[/align]
[align=left]①相同的范围(在同一个类中，名字空间作用域)；[/align]
[align=left]②函数名相同参数不同；[/align]
[align=left]③virtual 关键字可有可无[/align]
[align=left]④根据函数的参数列表来选择要调用的函数版本[/align]
[align=left]⑤静态联编[/align]
[align=left] [/align]
[align=left]覆盖override是指派生类函数覆盖基类函数，覆盖的特征是：[/align]
[align=left]①不同的范围(分别位于派生类与基类)；[/align]
[align=left]②函数名和参数都相同；[/align]
[align=left]③基类函数必须有virtual 关键字。(若没有virtual 关键字则称之为隐藏hide)[/align]

④覆盖是根据运行时对象的实际类型来选择要调用的虚virtual函数版本

⑤动态联编
override可以翻译为覆盖，从字面就可以知道，它是覆盖了一个方法并且对其重写，以求达到不同的作用。对我们来说最熟悉的覆盖就是对接口方法的实现，在接口中一般只是对方法进行了声明，而我们在实现时，就需要实现接口声明的所有方法。除了这个典型的用法以外，我们在继承中也可能会在子类覆盖父类中的方法。在覆盖要注意以下的几点：

1、覆盖的方法的标志必须要和被覆盖的方法的标志完全匹配，才能达到覆盖的效果；

2、覆盖的方法的返回值必须和被覆盖的方法的返回一致；

3、覆盖的方法所抛出的异常必须和被覆盖方法的所抛出的异常一致，或者是其子类；

4、被覆盖的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。

overload对我们来说可能比较熟悉，可以翻译为重载，它是指我们可以定义一些名称相同的方法，通过定义不同的输入参数来区分这些方法，然后再调用时，VM就会根据不同的参数样式，来选择合适的方法执行。在使用重载要注意以下的几点：

1、在使用重载时只能通过不同的参数样式。例如，不同的参数类型，不同的参数个数，不同的参数顺序（当然，同一方法内的几个参数类型必须不一样，例如可以是fun(int, float)，但是不能为fun(int, int)）；

2、不能通过访问权限、返回类型、抛出的异常进行重载；

3、方法的异常类型和数目不会对重载造成影响；

注:

虚函数表:编译器处理虚函数的方法是:给每个对象添加一个隐藏成员.隐藏成员中保存了一个指向函数地址数组的指针.这组数组称为Vtbl