当前位置：文档之家 › c++的函数重载、覆盖和隐藏

c++的函数重载、覆盖和隐藏

  • 格式：docx
  • 大小：22.72 KB
  • 文档页数：12

c++的函数重载、覆盖和隐藏1. 子类和父类返回值参数相同，函数名相同，有virtual关键字，则由对象的类型决定调用哪个函数。

2. 子类和父类只要函数名相同，没有virtual关键字，则子类的对象没有办法调用到父类的同名函数,父类的同名函数被隐藏了，也可以强制调用父类的同名函数class::funtion_name。

3. 子类和父类参数不同，函数名相同，有virtual关键字，则不存在多态性，子类的对象没有办法调用到父类的同名函数,父类的同名函数被隐藏了，也可以强制调用父类的同名函数class::funtion_name。

4. 子类和父类返回值不同，参数相同，函数名相同，有virtual关键字，则编译出错error C2555编译器不允许函数名参数相同返回值不同的函数重载。

“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) 42pb->f(3.14f); // 运行结果: Base::f(float) 3.14pb->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 objectpb->f(3.14f); //运行结果: Derived::f(float) 3.14pd->f(3.14f); //运行结果: Derived::f(float) 3.14// Bad : behavior depends on type of the pointerpb->g(3.14f); //运行结果: Base::g(float) 3.14pd->g(3.14f); //运行结果: Derived::g(int) 3// Bad : behavior depends on type of the pointerpb->h(3.14f); //运行结果: Base::h(float) 3.14pd->h(3.14f); //运行结果: Derived::h(float) 3.14}请大家注意，f()函数属于覆盖，而g()与h()属于隐藏。

从上面的运行结果，我们可以注意到在覆盖中，用基类指针和派生类指针调用函数f()时，系统都是执行的派生类函数f()，而非基类的f()，这样实际上就是完成的“接口”功能。

而在隐藏方式中，用基类指针和派生类指针调用函数f()时，系统会进行区分，基类指针调用时，系统执行基类的f()，而派生类指针调用时，系统“隐藏”了基类的f()，执行派生类的f()，这也就是“隐藏”的由来。

================================================================ ===--------------------------------------------------------------------------------------------------------------------------------------重载(overload)这个好理解,在同个space域同名的.参数必须不同,有关virtual无关.覆盖(override)同名字,同参数,有virtual覆盖好理解比如show()函数A派生了B如果B中的show()覆盖了A中的show()但B中仍然有两个show(),而不管是A类指针也好,B类对象调用也好,都只能调用B类自己的那个show();而从A类继承过来的show()函数真的就被覆盖了,没有了吗? 答应是不对的.这时可以在B类对象显示的调用A类继承过来的show();程序代码：#include <iostream>using namespace std;class A{public:virtual void show(){cout << a << endl;}int a;};class B:public A{public:void show(){A::show();//显示的调用自己类中的"由A类继承过来的show()函数"//像这种直接显示指出某个类的某个函数时,//编译器处理方式是这样的: 首先在自己类中找有没有A::show(),如果找到,调用.不在继续在A类中找//如果找不到,则在显示指出的那个类中(即A类)调用那个函数. 这里当然是在B类中可以找到A::show()//因为基类中指出了这个函数是virtual函数.}int b;};int main(){A a;a.a = 3;a.show();B b;b.b = 4;b.show();b.A::show(); //显示的调用自己类中的"由A类继承过来的show()函数"return 0;}总结:virtual, 覆盖.其实准确,通俗的讲B类还是有两个show(),只是调用由A继承过来的show()只能通过显示的调用方法[类名::virtual函数名]而不管是基类A的指针(B b; A *p = &b; p->show())或者派生类的对象(B b; b.show()),都只能调用B类的自己本身存在的show()函数-----------------------------------------------------------------------------------------------------------------------隐藏hide这个有点麻烦了...什么是隐藏情况?1,同名同参无virtual2,同名不同参不管有无virtual程序代码：class A{public:void show() {}; //编号1void rose(int a) {} //编号2};class B:public A{public:void show() {}; //编号3void rose(int a, int b) {}; //编号4};//类B中的show()和rose()明显是隐藏了类A的show()和rose()隐藏的理解:B类中其实有两个show(),两个rose();但为什么不叫重载呢?你会这样想,但我可以告诉你,因为类B中的两个show(),两个rose(),不是都可以被类B对象调用的.//----1----//编号1和编号2,在类B中哪怕存在,但只能通过类A的指针调用,而不能通过B类对象调用,如:程序代码：A *p = new B;p->show();p->rose(3);p->rose(3,5); //error//----2----//编号3和编程4,只能通过类B对象调用,而不能通过类A的指针调用,如:程序代码：B b;b.show();b.rose(3,5);b.rose(4); //error成员函数的重载、覆盖与隐藏成员函数的重载、覆盖（override）与隐藏很容易混淆，C++程序员必须要搞清楚概念，否则错误将防不胜防。

合集下载

c语言函数重载

c语言函数重载

c语言函数重载C语言是一种广受欢迎的计算机语言，以简单易学及其灵活的特性著称。

它不仅是一种编程语言，还是一种编程范式，用于更好地完成计算机程序的设计和开发。

在计算机程序设计和开发中，函数重载是一个灵活的方法，它可以有效地显示代码的可读性和可扩展性。

本文将介绍C语言函数重载的一般概念，并介绍如何使用它来提高代码可读性和可扩展性。

首先，让我们了解一下什么是函数重载。

函数重载是指在C语言中，允许不同参数引用同一个函数名称，而函数实现不同。

函数名称相同，但参数类型不同，就可以实现函数重载，这样可以提高代码的可读性和可扩展性。

函数重载的主要优势是提高代码的可读性和可扩展性。

由于函数的名称是唯一的，使用者可以更容易地理解函数的功能。

同时，使用者也可以更容易地添加新功能，而不必改变已经存在的函数，提高代码的可扩展性和可维护性。

函数重载还可以提高代码的可重复使用性。

如果两个函数做类似的功能，可以使用函数重载，用一个函数名称，实现不同功能，这样可以大大减少代码量，提高代码的可重复使用性。

函数重载也可以在多个不同的程序中使用，即跨程序函数重载。

函数可以在两个或多个不同的程序中被重载，共享相同的函数名称，这样，可以提高代码的可复用性，以及改进程序可维护性和可扩展性。

函数重载有其局限性。

首先，函数重载只能用于相同参数列表的函数，也就是说，函数重载不能用于不同参数列表的函数。

其次，函数重载只能用于同一个文件中的函数，跨文件的函数重载是不允许的。

最后，只有当参数列表不同时，函数重载才是有效的，如果参数列表相同的函数重载是无效的。

总而言之，C语言函数重载是一种灵活的编程范式，可以显示代码的可读性和可扩展性。

它有很多优势，如提高代码可读性、可重复使用性、可扩展性和可维护性等，但也有一些局限性。

谈谈重载(overload)覆盖(override)与隐藏、多态

谈谈重载(overload)覆盖(override)与隐藏、多态

2、Overload返回值类型不同不能作为不同的两个函数，Override应该完全一样的返回类型。
---------------------------------------------------------------
overload:
public a(){}
public a(int a){]
考虑这样两个类：
class Father {
public void doSomething(){}
public void doSomething(int a){}
public void doSomething(String s, int a){}
}
class Son extends Father {
public void doSomething(String s, int a) {}
public void doSomething(int a, String s){}
}
方法aaa Override
---------------------------------------------------------------
还有，overload一般发生在同一个类中的有着不同的参数名和(或)不同数量的参数的同名方法之间，但同名方法的返回值可以一样
隐藏是指派生类中的函数把基类中相同名字的函数屏蔽掉了。隐藏与另外两个概念表面上看来很像，很难区分，其实他们的关键区别就是在
多态的实现上。什么叫多态？简单地说就是一个接口，多种实现吧。
覆盖指的是派生类的虚拟函数覆盖了基类的同名且参数相同的函数！
重载(overload):
必须在一个域中,函数名称相同但是函数参数不同,重载的作用就是同一个函数有不同的行为,因此不是在一个域中的函数是无法构成重载的,这个
c函数重载

c函数重载

c函数重载C函数重载是C++中的一个非常重要的特性，它允许我们在同一个函数名下编写多个函数，以便根据不同的参数类型和数量进行重载，实现函数功能的多样性。

C函数重载的基本原理是在参数列表的类型、数量或顺序发生改变时，编译器会识别并生成对应的函数版本，并通过函数签名来区分不同的函数版本。

例如，我们可以定义以下重载函数：```cppint max(int a, int b);double max(double a, double b);float max(float a, float b, float c);```在这个例子中，我们将函数名都命名为max，但是它们分别接受不同数量和类型的参数。

当我们调用这些函数时，编译器根据参数类型和数量的不同选择正确的函数版本。

C函数重载的优势有：1.增加函数功能：C函数重载允许我们在同一函数下编写多个不同的函数，可以根据不同的情况选择调用不同的函数版本，这样就能够增加函数功能的弹性和可扩展性。

2.提高运行效率：函数重载的另一个好处是可以有效地减少冗余程序代码，提高程序的运行效率。

重载函数可以在不增加程序复杂度的情况下提供更多的功能选择，同时也能减少程序的维护难度和开发成本。

3.方便快捷：在函数重载中，我们可以使用相同的函数名、不同的参数类型，用一种更方便快捷的方式来编写代码。

这样做不仅使代码更易读，而且减少了错误发生的可能性。

C++编译器会根据函数参数类型和数量的不同来选择调用哪个函数，并且还能够进行类型转换。

这是C函数重载扩展能力的一部分，它可以通过函数签名来区分不同的函数版本，使程序功能更加强大和多样化。

总结：C++函数重载是一种能够增加程序的弹性和可扩展性的编程技术，它能够在不同的情况下自动选择正确的函数版本，减少程序冗余和改进程序的可读性。

尽管函数重载可能会使代码复杂化，但它仍是值得应用的高级编程技巧，可以极大地提升代码的效率和可维护性。

C++类成员函数的重写、重载和隐藏

C++类成员函数的重写、重载和隐藏

C++类成员函数的重写、重载和隐藏重载（overload）重载的定义为：在同⼀作⽤域中，同名函数的形式参数（参数个数、类型或者顺序）不同时，构成函数重载。

例如：class A{public: int func(int a); void func(int a, int b); void func(int a, int b, int c); int func(char* pstr, int a);};以上的四个函数均构成重载。

需要注意的是： 1.函数返回值类型与构成重载⽆任何关系 2.类的静态成员函数与普通成员函数可以形成重载 3.函数重载发⽣在同⼀作⽤域，如类成员函数之间的重载、全局函数之间的重载这⾥还需要注意⼀下 const重载：class D{public: void funcA(); //1 void funcA() const; //2 void funcB(int a); //3 void funcB(const int a); //4};在类D 中 funcA 与 const funcA是合法的重载，⽽两个 funcB 函数是⾮法的，不能通过编译。

原因是：顶层const不影响重载性，因为值传递的拷贝特性，想函数内传递的值类型形参的变化不会影响实参，所以有⽆const 对其⽽⾔是没有意义的。

调⽤规则：const对象默认调⽤const成员函数，⾮const对象默认调⽤⾮const成员函数；隐藏（hiding）隐藏定义：指不同作⽤域中定义的同名函数构成隐藏（不要求函数返回值和函数参数类型相同）。

⽐如派⽣类成员函数隐藏与其同名的基类成员函数、类成员函数隐藏全局外部函数。

例如：void hidefunc(char* pstr){ cout << "global function: " << pstr << endl;}class HideA{public: void hidefunc(){ cout << "HideA function" << endl; } void usehidefunc(){ //隐藏外部函数hidefunc，使⽤外部函数时要加作⽤域 hidefunc(); ::hidefunc("lvlv"); }};class HideB : public HideA{public: void hidefunc(){ cout << "HideB function" << endl; } void usehidefunc(){ //隐藏基类函数hidefunc，使⽤外部函数时要加作⽤域 hidefunc(); HideA::hidefunc(); }};隐藏的实质是；在函数查找时，名字查找先于类型检查。