重载、覆盖、重写(隐藏)


#include <iostream>
#include <stdio.h>
using namespace std;


/*
参考http://www.cnblogs.com/itech/archive/2010/06/04/1751532.html

Overload(重载):在C++程序中,可以将语义、功能相似的几个函数用同一个名字表示,但参数或返回值不同(包括类型、顺序不同),即函数重载。
(1)相同的范围(在同一个类中);
(2)函数名字相同;
(3)参数不同;
(4)virtual 关键字可有可无。

Override(覆盖):是指派生类函数覆盖基类函数,特征是:
(1)不同的范围(分别位于派生类与基类);
(2)函数名字相同;
(3)参数相同;
(4)基类函数必须有virtual 关键字。

Overwrite(重写, 也称隐藏):是指派生类的函数屏蔽了与其同名的基类函数,规则如下:
(1)如果派生类的函数与基类的函数同名,但是参数不同。此时,不论有无virtual
关键字,基类的函数将被隐藏(注意别与重载混淆)。
(2)如果派生类的函数与基类的函数同名,并且参数也相同,但是基类函数没有virtual
关键字。此时,基类的函数被隐藏(注意别与覆盖混淆)。
*/

class A {
public:
  // 隐藏规则1
  // 1) 函数名相同 && 参数不同
  // 2) 不论是否有virtual
  void hide_rule_1_no_virtual(){ cout << "A_1" << endl; }
  void hide_rule_1_virtual(){ cout << "A_2" << endl; }

  // 隐藏规则2
  // 1) 函数名相同 && 参数相同
  // 2) 无virtual
  void hide_rule_2(){ cout << "A_3" << endl; }

  // 覆盖规则
  // 1) 函数名相同 && 参数相同
  // 2) 有virtual
  virtual void overide(){ cout << "A_4" << endl; }
};

class B : public A{
public:
  void hide_rule_1_no_virtual(int i){ cout << "B_1" << endl; }
  void hide_rule_1_virtual(int i){ cout << "B_2" << endl; }

  void hide_rule_2(){ cout << "B_3" << endl; }

  void overide(){ cout << "B_4" << endl; }
};


int main(){
  A *a = new A;
  a->hide_rule_1_no_virtual();
  a->hide_rule_1_virtual();
  a->hide_rule_2();
  a->overide();
  cout << endl;

  B *b = new B;
  //b->hide_rule_1_no_virtual();  //被隐藏
  //b->hide_rule_1_virtual();     //被隐藏
  b->hide_rule_1_no_virtual(1);
  b->hide_rule_1_virtual(1);
  b->hide_rule_2();
  b->overide();
  cout << endl;

  A *c = new B;
  c->hide_rule_1_no_virtual();
  c->hide_rule_1_virtual();
  c->hide_rule_2();
  c->overide();

  int ttt = 0;
  return 0;
}


<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、付费专栏及课程。

余额充值