重载与覆盖的区别
1、⽅法的覆盖是⼦类和⽗类之间的关系，是垂直关系；⽅法的重载是同⼀个类中⽅法之间的关系，是⽔平关系。
2、覆盖只能由⼀个⽅法，或只能由⼀对⽅法产⽣关系；⽅法的重载是多个⽅法之间的关系。
3、覆盖要求参数列表相同；重载要求参数列表不同。
4、覆盖关系中，调⽤那个⽅法体，是根据对象的类型（对象对应存储空间类型）来决定；重载关系，是根据调⽤时的实参表与形参表来选择⽅法体的。
override可以翻译为覆盖，从字⾯就可以知道，它是覆盖了⼀个⽅法并且对其重写，以求达到不同的作⽤。对我们来说最熟悉的覆盖就是对接⼝⽅法的实现，在接⼝中⼀般只是对⽅法进⾏了声明，⽽我们在实现时，就需要实现接⼝声明的所有⽅法。除了这个典型的⽤法以外，我们在继承中也可能会在⼦类覆盖⽗类中的⽅法。在覆盖要注意以下的⼏点：
1、覆盖的⽅法的标志必须要和被覆盖的⽅法的标志完全匹配，才能达到覆盖的效果；
多态性与虚函数2、覆盖的⽅法的返回值必须和被覆盖的⽅法的返回⼀致；
3、覆盖的⽅法所抛出的异常必须和被覆盖⽅法的所抛出的异常⼀致，或者是其⼦类；
4、被覆盖的⽅法不能为private，否则在其⼦类中只是新定义了⼀个⽅法，并没有对其进⾏覆盖。
overload对我们来说可能⽐较熟悉，可以翻译为重载，它是指我们可以定义⼀些名称相同的⽅法，通过定义不同的输⼊参数来区分这些⽅法，然后再调⽤时，VM就会根据不同的参数样式，来选择合适的⽅法执⾏。在使⽤重载要注意以下的⼏点：
1、在使⽤重载时只能通过不同的参数样式。例如，不同的参数类型，不同的参数个数，不同的参数顺序（当然，同⼀⽅法内的⼏个参数类型必须不⼀样，例如可以是fun(int, float)，但是不能为fun(int, int)）；
2、不能通过访问权限、返回类型、抛出的异常进⾏重载；
3、⽅法的异常类型和数⽬不会对重载造成影响；
overload编译时的多态
override运⾏时的多态
⾯向对象程序设计中的另外⼀个重要概念是多态性。在运⾏时，可以通过指向基类的指针，来调⽤实现派⽣类中的⽅法。可以把⼀组对象放到⼀个数组中，然后调⽤它们的⽅法，在这种场合下，多态性作
⽤就体现出来了，这些对象不必是相同类型的对象。当然，如果它们都继承⾃某个类，你可以把这些派⽣类，都放到⼀个数组中。如果这些对象都有同名⽅法，就可以调⽤每个对象的同名⽅法。
同⼀操作作⽤于不同的对象，可以有不同的解释，产⽣不同的执⾏结果，这就是多态性。多态性通过派⽣类重载基类中的虚函数型⽅法来实现。
在⾯向对象的系统中，多态性是⼀个⾮常重要的概念，它允许客户对⼀个对象进⾏操作，由对象来完成⼀系列的动作，具体实现哪个动作、如何实现由系统负责解释。
“多态性”⼀词最早⽤于⽣物学，指同⼀种族的⽣物体具有相同的特性。在C#中，多态性的定义是：同⼀操作作⽤于不同的类的实例，不同的类将进⾏不同的解释，最后产⽣不同的执⾏结果。C#⽀持两种类型的多态性：
●编译时的多态性
编译时的多态性是通过重载来实现的。对于⾮虚的成员来说，系统在编译时，根据传递的参数、返回的类型等信息决定实现何种操作。
●运⾏时的多态性
运⾏时的多态性就是指直到系统运⾏时，才根据实际情况决定实现何种操作。C#中，运⾏时的多态性通过虚成员实现。
编译时的多态性为我们提供了运⾏速度快的特点，⽽运⾏时的多态性则带来了⾼度灵活和抽象的特点。
举个简单的例⼦：
void test(CBase *pBase)
{
pBase->VirtualFun();
}
这段程序编译的时刻并不知道运⾏时刻要调⽤那个⼦类的函数，所以编译的时刻并不会选择跳转到那个函数去!如果不是虚函数，那么跳转的伪汇编代码应该是call VirtuallFun！但当是虚函数的时候，就不能这样了，⽽是变成了call pBase->虚函数表⾥的⼀个变量，不同的⼦类在这个变量含有不同的函数地
址，这就是所谓的运⾏时刻了。但事实上 pBase->虚函数表⾥的⼀个变量也是在编译时刻就产⽣的的，它是固定的。所以运⾏时刻，还是编译时刻事实上也并不严密，重要的还是理解它的实质！
虚函数只是⼀个函数指针表，具体调⽤哪个类的相关函数，要看运⾏是，对象指针或引⽤所指的真实类型，由于⼀个基类的指针或引⽤可以指向不同的派⽣类，所以，当⽤基类指针或引⽤调⽤虚函数时，结果是由运⾏时对象的类型决定的
>>>>>>>>>>>>>>>>#
“overload”翻译过来就是：超载，过载，重载，超出标准负荷；“override”翻译过来是：重置，覆盖，使原来的失去效果。
先来说说重载的含义，在⽇常⽣活中我们经常要清洗⼀些东西，⽐如洗车、洗⾐服。尽管我们说话的时候并没有明确地说⽤洗车的⽅式来洗车，或者⽤洗⾐服的⽅式来洗⼀件⾐服，但是谁也不会⽤洗⾐服的⽅式来洗⼀辆车，否则等洗完时车早就散
架了。我们并不要那么明确地指出来就⼼知肚明，这就有重载的意思了。在同⼀可访问区内被声名的⼏个具有不同参数列的（参数的类型、个数、顺序不同）同名函数，程序会根据不同的参数列来确定具体调⽤哪个函数，这种机制叫重载，重载不关⼼函数的返回值类型。这⾥，“重载”的“重”的意思不同于“轻重”的“重”，它是“重复”、“重叠”的意思。例如在同⼀可访问区内有：
① double calculate(double);
② double calculate(double，double);
③ double calculate(double, int);
④ double calculate(int, double);
⑤ double calculate(int);
⑥ float calculate(float);
⑦ float calculate(double);
六个同名函数calculate，①②③④⑤⑥中任两个均构成重载，⑥和⑦也能构成重载，⽽①和⑦却不能构成重载，因为①和⑦的参数相同。
覆盖是指派⽣类中存在重新定义的函数，其函数名、参数列、返回值类型必须同⽗类中的相对应被覆盖的函数严格⼀致，覆盖函数和被覆盖函数只有函数体（花括号中的部分）不同，当派⽣类对象调⽤⼦类中该同名函数时会⾃动调⽤⼦类中的覆盖版本，⽽不是⽗类中的被覆盖函数版本，这种机制就叫做覆盖。
下⾯我们从成员函数的⾓度来讲述重载和覆盖的区别。
成员函数被重载的特征有：
1) 相同的范围（在同⼀个类中）；
2) 函数名字相同；
3) 参数不同；
4) virtual关键字可有可⽆。
覆盖的特征有：
1) 不同的范围（分别位于派⽣类与基类）；
2) 函数名字相同；
3) 参数相同；
4) 基类函数必须有virtual关键字。
⽐如，在下⾯的程序中：
#include <iostream.h>
class Base
{
public:
void f(int x){ cout << "Base::f(int) " << x << endl; }
void f(float x){ cout << "Base::f(float) " << x << endl; }
virtual void g(void){ cout << "Base::g(void)" << endl;}
};
class Derived : public Base
{
public:
virtual void g(void){ cout << "Derived::g(void)" << endl;}
};
void main(void)
{
Derived d;
Base *pb = &d;
pb->f(42); // 运⾏结果: Base::f(int) 42
pb->f(3.14f); // 运⾏结果: Base::f(float) 3.14
pb->g(); // 运⾏结果: Derived::g(void)
}
函数Base::f(int)与Base::f(float)相互重载，⽽Base::g(void)被Derived::g(void)覆盖。
隐藏是指派⽣类的函数屏蔽了与其同名的基类函数，规则如下：
1) 如果派⽣类的函数与基类的函数同名，但是参数不同。此时，不论有⽆virtual关键字，基类的函数将被隐藏（注意别与重载混淆）。
2) 如果派⽣类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）。
⽐如，在下⾯的程序中：
#include <iostream.h>
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; }
};
通过分析可得：
1) 函数Derived::f(float)覆盖了Base::f(float)。
2) 函数Derived::g(int)隐藏了Base::g(float)，注意，不是重载。
3) 函数Derived::h(float)隐藏了Base::h(float)，⽽不是覆盖。
看完前⾯的⽰例，可能⼤家还没明⽩隐藏与覆盖到底有什么区别，因为我们前⾯都是讲的表⾯现象，怎样的实现⽅式，属于什么情况。下⾯我们就要分析覆盖与隐藏在应⽤中到底有什么不同之处。在下⾯的程序中bp和dp指向同⼀地址，按理说运⾏结果应该是相同的，可事实并⾮如此。
void main(void)
{
Derived d;
Base *pb = &d;
Derived *pd = &d;
// Good : behavior depends solely on type of the object
pb->f(3.14f); //运⾏结果: Derived::f(float) 3.14
pd->f(3.14f); //运⾏结果: Derived::f(float) 3.14
// Bad : behavior depends on type of the pointer
pb->g(3.14f); //运⾏结果: Base::g(float) 3.14
pd->g(3.14f); //运⾏结果: Derived::g(int) 3
// Bad : behavior depends on type of the pointer
pb->h(3.14f); //运⾏结果: Base::h(float) 3.14
pd->h(3.14f); //运⾏结果: Derived::h(float) 3.14
}
请⼤家注意，f()函数属于覆盖，⽽g()与h()属于隐藏。从上⾯的运⾏结果，我们可以注意到在覆盖中，⽤基类指针和派⽣类指针调⽤函数f()时，系统都是执⾏的派⽣类函数f()，⽽⾮基类的f()，这样实际上就是完成的“接⼝”功能。⽽在隐藏⽅式中，⽤基类指针和派⽣类指针调⽤函数f()时，系统会进⾏区分，基类
指针调⽤时，系统执⾏基类的f()，⽽派⽣类指针调⽤时，系
统“隐藏”了基类的f()，执⾏派⽣类的f()，这也就是“隐藏”的由来。
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。
c++类与对象基础知识点
« 上一篇
virtual析构函数
下一篇 »
发表评论