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

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

1. 重载(overload)

重载的概念相对简单,只有在用一类定义中的同名成员函数才存在重载关系,主要特点是函数的参数类型和数目有所不同,但不能出现函数参数的个数和类型均相同,仅仅依靠返回值类型不同来区分的函数,这和普通函数的重载是完全一致的。另外,重载和成员函数是否是虚函数无关。

成员函数被重载的特征:

  1. 相同的范围(在用一个类中);

  2. 相同的函数名字;

  3. 不同的参数列表;

  4. virtual 关键字可有可无。

2. 覆盖(overrid)

覆盖,又名重写:在派生类中覆盖基类中的同名函数,要求基类函数必须是虚函数,且:

1)与基类的虚函数有相同的参数个数;
2)与基类的虚函数有相同的参数类型;
3)与基类的虚函数有相同的返回类型:或者与基类虚函数的相同,或者都返回指针(或引用),并且派生类虚函数所返回的指针(或引用)类型是基类中被替换的虚函数所返回的指针(或引用)类型的子类型(派生类型)。

覆盖的特征如下:

  1. 不同的范围(分别位于派生类与基类);
  2. 相同的函数名字;
  3. 相同的参数;
  4. 基类函数必须有 virtual 关键字。

重载与覆盖的区别如下:

  1. 覆盖是子类和父类之间的关系,是垂直关系;重载是同一个类中不同方法之间的关系,是水平关系;
  2. 覆盖要求参数列表相同,重载要求参数列表不同;覆盖要求返回类型相同,重载则不要求;
  3. 覆盖关系中,调用方法体示根据对象的类型来决定的,重载关系是根据调用时的实参表与形参表来选择方法体的。

3. 隐藏(hide, oversee)

隐藏指的是在某些情况下,派生类中的函数屏蔽了基类中的同名函数,这些情况包括:

  1. 两个函数参数相同,但是基类函数不是虚函数;(注意与覆盖区分)
  2. 两个函数参数不同,无论基类函数是否是虚函数,基类函数都会被屏蔽。(注意与重载区分)

示例分析

  1. 函数Derived::f(float)覆盖了Base::f(float)。
  2. 函数Derived::g(int)隐藏了Base::g(float),而不是重载。
  3. 函数Derived::h(float)隐藏了Base::h(float),而不是覆盖。
  4. 父类指针指向子类实例对象,调用普通“重写”方法时,会调用父类中的方法。而调用被子类覆盖虚函数时,会调用子类中的方法。子类中被覆盖的虚函数的运行方式是动态绑定的,与当前指向类实例的父类指针类型无关,仅和类实例对象本身有关。
#include <iostream>

using namespace std;

 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; }
};

int main()
{
    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        (surprise!)
    // Bad : behavior depends on type of the pointer
    pb->h(3.14f); // Base::h(float) 3.14      (surprise!)
    pd->h(3.14f); // Derived::h(float) 3.14
    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、付费专栏及课程。

余额充值