C++重载覆盖隐藏

最新推荐文章于 2024-11-01 23:22:57 发布

GouplovXim1314

最新推荐文章于 2024-11-01 23:22:57 发布

阅读量653

点赞数 4

CC 4.0 BY-SA版权

分类专栏： C++ 5月 2018年文章标签： C++ 重载覆盖隐藏

本文链接：https://blog.youkuaiyun.com/GouplovXim1314/article/details/80445182

 
 重载 

 
 前提：(1)同一作用域 

 
 (2)函数名相同 

 
 要求：不同形参表 

 
 注： 

 
 返回类型和参数的缺省值不参与重载识别。函数前缀的访问控制（public/protected/private）不影响重载。在不同的名字空间声明的函数不是重载。除 main 函数之外的任何函数都可以重载。 

 
 重载的几种情况： 

(1)

 
 形参是引用，非引用时 

 
 void func(int &x); 

 
 void func(int x); 

 
 //不属于重载 

(2)

 
 形参是const引用，非const引用时 

 
 void func(const int &x); 

 
 void func(int &x); 

 
 //属于重载 

(3)

 
 形参是普通指针，指向常量的指针时 

 
 void func(int *p); 

 
 void func(int const *p); 

 
 //属于重载 

(4)

最低0.47元/天解锁文章

200万优质内容无限畅学

确定要放弃本次机会？

福利倒计时

: :

立减 ¥

普通VIP年卡可用

立即使用

GouplovXim1314

关注关注

4
点赞
踩
17

收藏

觉得还不错? 一键收藏
0
评论
分享

复制链接

分享到 QQ

分享到新浪微博

扫一扫
举报

举报

专栏目录

高质量c++(重载、覆盖、隐藏)

zgbsoap的专栏

12-30

2万+

成员函数的重载、覆盖与隐藏成员函数的重载、覆盖（override）与隐藏很容易混淆，C++程序员必须要搞清楚概念，否则错误将防不胜防。8.2.1 重载与覆盖成员函数被重载的特征：（1）相同的范围（在同一个类中）；（2）函数名字相同；（3）参数不同；（4）virtual 关键字可有可无。覆盖是指派生类函数覆盖基类函数，特征是：（1）不同的范围（分别位于派生类与基类）；（2）函数名字相同；（3）参数相

C++中的重载、覆盖、隐藏

L_jiahao的博客

03-31

527

一、重载概念：重载是指相同的范围中（例如一个类）不同的函数使用相同的函数名，但是函数的参数个数或类型或顺序不同。调用的时候根据函数的参数来区别不同的函数。重载函数的返回值可相同也可不同。重载在编译期就可以确定了。注意重载是C++中独有的C语言中没有重载，要追究这一问题那就需要从编译的角度去分析这两者的不同。例如void fun(int a,int b); 这个函数在C++和C编译后的符号是...

参与评论您还未登录，请先登录后发表或查看评论

C++中的重载、覆盖、隐藏介绍

01-20

前几天面试时被问及C++中的覆盖、隐藏，概念基本答不上来，只答了怎么用指针实现多态，也还有遗漏。最终不欢而散。回来后在网上查找学习了一番，做了这个总结。其中部分文字借用了别人的博客，望不要见怪。 •概念一、重载（overload）指函数名相同，但是它的参数表列个数或顺序，类型不同。但是不能靠返回类型来判断。（1）相同的范围（在同一个作用域中）；（2）函数名字相同；（3）参数不同；（4）virtual 关键字可有可无。（5）返回值可以不同；二、重写（也称为覆盖 override）是指派生类重新定义基类的虚函数，特征是：（1）不在同一个作用域（分别位于派生类与基类）；（2

C++重载、覆盖与隐藏

weixin_37977062的博客

03-20

354

重载前提：(1)同一作用域 (2)函数名相同要求：不同形参表注：返回类型和参数的缺省值不参与重载识别。函数前缀的访问控制（public/protected/private）不影响重载。在不同的名字空间声明的函数不是重载。除 main 函数之外的任何函数都可以重载。重载的几种情况： (1) 形参是引用，非引用时 void

覆盖、重载、隐藏

ali_sure的专栏

11-08

775

多态 ...我猜楼主是问的覆盖、重载、隐藏吧？＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝“overload”翻译过来就是：超载，过载，重载，超出标准负荷；“override”翻译过来是：重置，覆盖,使原来的失去效果。先来说说重载的含义，在日常生活中我们经常要清洗一些东西，比如洗车、洗衣服。尽管我们说话的时候并没有明确地说用洗车的方式来洗车，或者用洗衣服的方式来洗一件衣服，但是谁也不会用

【C++ - 19】C++中重载和覆盖的区别

热门推荐

藏经阁 | 玄苦

05-28

1万+

一. 重载（overload） 1. 重载指的是函数具有的不同的参数列表，而函数名相同的函数。重载要求参数列表必须不同，比如参数的类型不同、参数的个数不同、参数的顺序不同。 2. 如果仅仅是函数的返回值不同是没办法重载的，因为重载要求参数列表必须不同。 3. 程序是根据参数列表来确定具体要调用哪个函数的 4. 看下面几个例子 void Fun(int a); void Fun(d...

C++ ---重载、覆盖、隐藏

JachinYang的博客

08-14

226

1.重载关系：一组函数要重载，必须处在同一个作用域，而且函数名相同，参数列表不同.#1与#2就是重载关系 2.隐藏关系：（作用域的隐藏）在继承结构中，派生类的同名成员函数，把基类的同名成员函数（非虚函数）给隐藏掉了 #1和#3#2和#3都是隐藏关系如果想调用基类同名成员函数，就得添加基类作用域Base:: 3.覆盖关系: 虚函数表中虚函数地址的覆盖；如果...

c++重载，覆盖，隐藏

weixin_44778940的博客

05-24

549

参考大佬成员函数重载： 1、同一个类； 2、函数名字参数一模一样； 3、virtual可有可无；覆盖（重写）：（派生类函数覆盖基类函数） 1、不一个类（派生或者继承关系） 2、函数参数名字一模一样； 3、基类中这个函数必须要有virtual; 隐藏：（派生） 1、跟基类函数名字一样，但是参数类型或者个数不同，基类的函数都会被隐藏； 2、如果跟基类函数一模一样，参数名字都一样（1）基类如果有virtual ，这是覆盖；（2）基类没有virtual，这是隐藏；

C++ 重载、覆盖和隐藏

casic207的博客

06-18

294

#include <iostream> class Parent { public: Parent() { std::cout << __FUNCTION__ << std::endl; } virtual ~Parent() { std::cout << __FUNCTION__ << std::endl; } void f1() { ...

C/C++ 知识点：重载、覆盖和隐藏

个人技术博客

11-01

1494

函数重载允许在同一作用域内声明多个同名但参数列表不同的函数的特性，是C++实现静态多态（编译期）的形式。这里的参数列表不同，可以是指参数的数量不同、参数的类型不同，或者参数的顺序不同。函数的返回类型并不参与重载的区分。覆盖是指派生类中的成员函数重新定义基类中的虚函数。当派生类中存在一个与基类虚函数同名、参数列表相同且返回类型相同的成员函数时，就发生了覆盖。public:public:void show() override { // 使用override关键字明确表示这是一个覆盖操作。

c++ 重载覆盖隐藏

TuxedoLinux的博客

01-09

621

c++

c++继承、重载、覆盖、隐藏

hallyz的博客

06-06

600

1. 继承：即父类实现的函数，在子类中即可调用。 2. 重载：相同作用内，如一个类中，函数名相同，但函数形参不同。 3. 覆盖：子类和父类中函数名相同，形参相同，基类中有virtual关键字，平常用的最多virtual实现的功能即是覆盖。 4. 隐藏：子类和父类的函数名相同，形参不同，无论基类中有无virtual关键字，此时父类中的函数被隐藏；子类和父类的函数名相同，形参相同，父类中无virtual关键字（有关键字即为覆盖，此处可看出覆盖和隐藏的区别）继承继承是基础，有了继承才牵扯出覆盖和隐藏，覆

c++之函数覆盖，重载，隐藏

BYTEDANCE的博客

08-23

863

c++之函数覆盖，重载，隐藏及抽象类和虚析构

C++中的重载、覆盖（重写）和隐藏

scmuzi18的博客

03-20

1086

类中成员函数被重载的特征： 1、相同的作用域（同一个类中）； 2、函数名字相同； 3、参数不同； 4、virtual关键字可有可无。覆盖是指派生类函数覆盖基类函数，特征是： 1、不同的作用域（基类和派生类）； 2、函数名字相同； 3、参数相同； 4、基类函数必须有virtual关键字。隐藏指派生类函数屏蔽了与其同名的基类函数，特征是： 1、如果派生类的函数与基类的函数同名，

C++的重载、覆盖和隐藏

sheer999的博客

09-11

128

函数重载：只有在同一作用域中的同名函数才存在函数重载、重载的函数的函数名必须相同，但函数的参数类型和参数个数不同；但如果函数名、函数类型和个数相同，仅仅只有返回类型不同的两个函数不是函数重载；而且函数重载与函数是否是虚函数无关。覆盖：主要是针对类成员函数，且对于基类和派生类而言；在派生类中覆盖基类的同名函数，要求两个函数的函数名、函数个数、参数类型和返回类型都必须相同，且基类函数...

C++中的重载与覆盖

test

01-14

362

1. 成员函数被重载的特征：相同的范围函数名字相同参数不同 virtual关键字可有可无2. 覆盖是指派生类函数覆盖基类函数，特征是不同的范围（分别位于派生类与基类）函数名字相同参数相同基类函数必须有virtual关键字#include <iostream> using namespace std; class Base{ public: void f(int x)

【C++】重载覆盖和隐藏

GoingJack博客

07-16

320

理论知识 1，重载关系一组函数要重载必须要处于同一作用域当中，而且函数名字相同，参数列表不同。 3，覆盖关系基类和派生类的方法，返回值、函数名以及参数列表都相同，而且基类的方法是虚函数，那么派生类的方法就自动处理成虚函数，它们之间成为覆盖关系 2，隐藏关系在继承结构中，派生类的同名成员把基类的同名成员给隐藏调用了。例子第一个 #include<iostr...

重写重载覆盖隐藏的区别

最新发布

07-29

<think>重写（Override）、重载（Overload）、覆盖（Override）和隐藏（Hiding）是C++中容易混淆的几个概念。下面我将逐一解释它们的区别，并给出相应的代码示例。 1. **重载（Overload）**： - 发生在同一个作用域内（例如同一个类中）。 - 函数名相同，但参数列表不同（参数的类型、个数或顺序不同）。 - 返回类型可以相同也可以不同，但仅返回类型不同不足以构成重载。 - 注意：重载与继承无关。 2. **覆盖（Override）**（也称为重写）： - 发生在继承体系中，基类和派生类的成员函数之间。 - 派生类中重新定义基类中的虚函数（必须有`virtual`关键字）。 - 函数名、参数列表、返回类型必须完全相同（协变返回类型除外）。 - 覆盖是多态性的体现。 3. **隐藏（Hiding）**： - 发生在继承体系中，基类和派生类的成员函数之间。 - 如果派生类中定义了与基类同名的函数（无论参数是否相同），且该函数不是覆盖（即基类函数不是虚函数，或者派生类函数没有用`virtual`声明），则基类中所有同名函数（包括重载版本）都会被隐藏。 - 隐藏后，在派生类中无法直接访问基类的同名函数（除非使用作用域运算符`::`）。 4. **重写（Override）**：在C++中，覆盖（Override）通常被称为重写。所以覆盖和重写是同一个概念。下面通过代码示例来说明： ```cpp #include <iostream> using namespace std; class Base { public: // 重载示例：同一个类中的函数名相同，参数不同 void func() { cout << "Base::func()" << endl; } void func(int) { cout << "Base::func(int)" << endl; } // 重载func // 虚函数，用于覆盖（重写） virtual void virtFunc() { cout << "Base::virtFunc()" << endl; } // 非虚函数，可能被隐藏 void nonVirtFunc() { cout << "Base::nonVirtFunc()" << endl; } }; class Derived : public Base { public: // 重载：在Derived类中重载func（但注意，这会隐藏基类的所有func函数） void func() { cout << "Derived::func()" << endl; } // 隐藏了Base::func()和Base::func(int) // 覆盖（重写）基类的虚函数 void virtFunc() override { cout << "Derived::virtFunc()" << endl; } // 隐藏基类的nonVirtFunc（因为同名，且不是虚函数） void nonVirtFunc() { cout << "Derived::nonVirtFunc()" << endl; } }; int main() { Derived d; // 调用Derived::func()，因为基类的func被隐藏 d.func(); // d.func(1); // 错误：Base::func(int)被隐藏 // 通过作用域运算符调用被隐藏的基类函数 d.Base::func(); d.Base::func(1); // 多态：通过基类指针调用覆盖的虚函数 Base* p = &d; p->virtFunc(); // 输出Derived::virtFunc() // 非虚函数，静态绑定，调用基类版本 p->nonVirtFunc(); // 输出Base::nonVirtFunc() // 直接调用派生类的nonVirtFunc d.nonVirtFunc(); // 输出Derived::nonVirtFunc() return 0; } ``` **解释**： - 在`Base`类中，`func`和`func(int)`是重载关系。 - 在`Derived`类中，定义了一个`func()`函数，它隐藏了基类中所有的`func`函数（包括`func()`和`func(int)`）。因此，在`Derived`对象上不能直接调用`func(int)`，除非使用作用域运算符。 - `virtFunc`是虚函数，在`Derived`中被覆盖（重写）。通过基类指针调用时，根据实际对象类型调用派生类的版本。 - `nonVirtFunc`在基类中是非虚函数，在派生类中重新定义，因此它隐藏了基类的版本。通过基类指针调用时，由于是静态绑定，调用基类版本；通过派生类对象调用时，调用派生类版本。 **总结**： - **重载**：同一作用域，同名函数参数不同。 - **覆盖（重写）**：派生类重新定义基类的虚函数，函数签名相同，用于实现多态。 - **隐藏**：派生类中定义了与基类同名的函数（无论参数是否相同），导致基类同名函数被隐藏（除非使用作用域运算符显式调用）。 §§相关问题§§: 1. 什么是C++中的静态绑定和动态绑定？ 2. 虚函数表（vtable）是如何实现多态的？ 3. 在C++11中，`override`关键字的作用是什么？ 4. 为什么在基类中，析构函数通常要声明为虚函数？</think>在C++中，重写（Override）、重载（Overload）、覆盖（Override）和隐藏（Hiding）是函数处理的四种不同机制，它们的区别如下： --- ### 1. **重载（Overload）** - **定义**：在同一作用域内，函数名相同但参数列表不同（参数类型、数量或顺序不同） - **特点**： - 静态绑定（编译时决定调用哪个函数） - 与返回值类型无关 - 可在同一类或全局作用域中发生 ```cpp class Example { public: void func(int x); // #1 void func(double x); // #2 重载：参数类型不同 void func(int x, int y); // #3 重载：参数数量不同 }; ``` --- ### 2. **覆盖/重写（Override）** - **定义**：派生类重新定义基类的**虚函数**，函数签名完全相同 - **特点**： - 动态绑定（运行时通过虚函数表决定） - 必须使用`virtual`关键字声明（基类） - 函数签名（函数名、参数列表、const修饰）必须完全一致 ```cpp class Base { public: virtual void show() { cout << "Base"; } // 虚函数 }; class Derived : public Base { public: void show() override { cout << "Derived"; } // 覆盖基类虚函数 }; ``` --- ### 3. **隐藏（Hiding）** - **定义**：派生类定义了与基类**同名函数**（无论参数是否相同），导致基类同名函数被隐藏 - **特点**： - 静态绑定（编译时决定） - 不需要虚函数 - 基类函数被完全隐藏（即使参数不同） ```cpp class Base { public: void print(int x) { cout << "Base"; } }; class Derived : public Base { public: void print() { cout << "Derived"; } // 隐藏基类的print(int) }; // 使用示例 Derived d; d.print(); // 正确：调用Derived::print() d.print(42); // 错误：Base::print(int)被隐藏！ ``` --- ### 关键区别总结 | 特性 | 作用域 | 绑定方式 | 函数要求 | 多态支持 | |------------|--------------|------------|------------------------------|----------| | **重载** | 同一作用域 | 静态绑定 | 参数列表不同 | ❌ | | **覆盖** | 继承体系 | 动态绑定 | 必须是虚函数，签名完全相同 | ✅ | | **隐藏** | 继承体系 | 静态绑定 | 同名即可（无视参数和虚函数）| ❌ | > 📌 **注意**： > - "重写"和"覆盖"是同一概念的不同表述 > - 隐藏可通过作用域运算符访问基类函数：`d.Base::print(42);` --- ### 代码验证示例 ```cpp #include <iostream> using namespace std; class Base { public: virtual void virtFunc() { cout << "Base virtFunc\n"; } void nonVirtFunc() { cout << "Base nonVirtFunc\n"; } void overload(int x) { cout << "Base::int\n"; } }; class Derived : public Base { public: // 覆盖虚函数（重写） void virtFunc() override { cout << "Derived virtFunc\n"; } // 隐藏基类非虚函数 void nonVirtFunc() { cout << "Derived nonVirtFunc\n"; } // 重载（在同一作用域） void overload(double x) { cout << "Derived::double\n"; } }; int main() { Derived d; Base* p = &d; // 动态绑定（覆盖） p->virtFunc(); // 输出: Derived virtFunc // 静态绑定（隐藏） p->nonVirtFunc(); // 输出: Base nonVirtFunc（无多态） d.nonVirtFunc(); // 输出: Derived nonVirtFunc // 重载与隐藏 d.overload(3.14); // 输出: Derived::double（重载） d.overload(42); // 错误！Base::overload(int)被隐藏 d.Base::overload(42); // 正确：显式调用基类函数 } ```