重写 重载 隐藏

本文详细解析了C++中函数重写、重载与隐藏的概念及其区别,重点介绍了函数隐藏的规则及如何区分函数隐藏与重写、重载。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >


重写 重载 隐藏

  (2011-11-17 16:20:05)
标签: 

杂谈

分类: c

 “隐藏”是指派生类的函数屏蔽了与其同名的基类函数,具体规则:

  如果派生类的函数与基类的函数同名,但是参数不同。此时,若基类无virtual关键字,基类的函数将被隐藏。(注意别与重载混淆,虽然函数名相同参数不同应称之为重载,但这里不能理解为重载,因为派生类和基类不在同一名字空间作用域内。这里理解为隐藏) 如果派生类的函数与基类的函数同名,但是参数不同。此时,若基类有virtual关键字,基类的函数将被隐式继承到派生类的中。vtable此时派生类vtable中的函数指向基类版本的函数地址。同时这个新的函数版本添加到派生类中,作为派生类的重载版本。但在基类指针实现多态调用函数方法时,这个新的派生类函数版本将会被隐藏。 如果派生类的函数与基类的函数同名,并且参数也相同,但是基类函数没有virtual关键字。此时,基类的函数被隐藏。(注意别与覆盖混淆,这里理解为隐藏)。 如果派生类的函数与基类的函数同名,并且参数也相同,但是基类函数有virtual关键字。此时,基类的函数不会被“隐藏”。[

-----------------------就近原则----取派生类,

 

 

,这称为函数的覆盖(override)。构成函数覆盖的条件为:

  n 基类函数必须是虚函数(使用virtual关键字进行声明)。

  n 发生覆盖的两个函数要分别位于派生类和基类中。

  n 函数名称与参数列表必须完全相同。

  由于C++的多态性是通过虚函数来实现的,所以函数的覆盖总是和多态关联在一起。在函数覆盖的情况下,编译器会在运行时根据对象的实际类型来确定要调用的函数。

 

 

 

这种情况称为函数的隐藏。所谓隐藏,是指派生类中具有与基类同名的函数(不考虑参数列表是否相同),从而在派生类中隐藏了基类的同名函数。

  初学者很容易把函数的隐藏与函数的覆盖、重载相混淆,我们看下面两种函数隐藏的情况:

  (1)派生类的函数与基类的函数完全相同(函数名和参数列表都相同),只是基类的函数没有使用virtual关键字。此时基类的函数将被隐藏,而不是覆盖(请参照上文讲述的函数覆盖进行比较)。

  (2)派生类的函数与基类的函数同名,但参数列表不同,在这种情况下,不管基类的函数声明是否有virtual关键字,基类的函数都将被隐藏。注意这种情况与函数重载的区别,重载发生在同一个类中。

 

 

  当隐藏发生时,如果在派生类的同名函数中想要调用基类的被隐藏函数,可以使用“基类名::函数名(参数)”的语法形式。例如,要在Derived类的fn(int)方法中调用Base类的fn()方法,可以使用Base::fn()语句。

  有的读者可能会想,我怎样才能更好地区分覆盖和隐藏呢?实际上只要记住一点:函数的覆盖是发生在派生类与基类之间,两个函数必须完全相同,并且都是虚函数。那么不属于这种情况的,就是隐藏了。

<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); // 正确:显式调用基类函数 } ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值