重写、覆盖、重载、隐藏、多态几个概念的区别分析

本文详细解析了C++中方法的重写(override)、重载(overload)及隐藏规则,通过具体示例展示了不同情况下函数的行为差异,帮助读者深入理解并正确使用这些特性。

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

override->重写(=覆盖)、overload->重载、polymorphism -> 多态
 

override是重写(覆盖)了一个方法,以实现不同的功能。一般是用于子类在继承父类时,重写(重新实现)父类中的方法。
成员函数的重载(overload)、覆盖(override)与隐藏很容易混淆,C++程序员必须要搞清楚概念,否则错误将防不胜防。

1   重载与覆盖
成员函数被重载的特征:
(1)相同的范围(在同一个类中)   ;
(2)函数名字相同;
(3)参数不同;
(4)virtual   关键字可有可无。

覆盖是指派生类函数覆盖基类函数,特征是:
(1)不同的范围(分别位于派生类与基类)   ;
(2)函数名字相同;
(3)参数相同;
(4)基类函数必须有   virtual   关键字。
示   例   1   中   ,   函   数   Base::f(int)   与   Base::f(float)   相互重载,   而   Base::g(void)   被   Derived::g(void)覆盖。

#include   <iostream>

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)   42
        pb-> f(3.14f);       //   Base::f(float)   3.14
        pb-> g();         //   Derived::g(void)
}

示例   1   成员函数的重载和覆盖

2   令人迷惑的隐藏规则
本来仅仅区别重载与覆盖并不算困难,   但是   C++的隐藏规则使问题复杂性陡然增加。这里“隐藏”是指派生类的函数屏蔽了与其同名的基类函数,规则如下:

(1)如果派生类的函数与基类的函数同名,但是参数不同。此时,不论有无   virtual   关键字,基类的函数将被隐藏(注意别与重载混淆)   。
(2)如果派生类的函数与基类的函数同名,并且参数也相同,但是基类函数没有   virtual关键字。此时,基类的函数被隐藏(注意别与覆盖混淆)   。

示例程序   2(a)中:
(1)函数   Derived::f(float)覆盖了   Base::f(float)。
(2)函数   Derived::g(int)隐藏了   Base::g(float),而不是重载。
(3)函数   Derived::h(float)隐藏了   Base::h(float),而不是覆盖。


#include   <iostream>

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

示例   2(a)成员函数的重载、覆盖和隐藏

据作者考察,很多   C++程序员没有意识到有“隐藏”这回事。由于认识不够深刻,“隐藏”的发生可谓神出鬼没,常常产生令人迷惑的结果。

示例   2(b)中,bp   和   dp   指向同一地址,按理说运行结果应该是相同的,可事实并非这样。

void   main(void)
...{
        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
}

示例   2(b)   重载、覆盖和隐藏的比较

3   摆脱隐藏
隐藏规则引起了不少麻烦。示例   3   程序中,语句   pd-> f(10)的本意是想调用函数Base::f(int),但是   Base::f(int)不幸被   Derived::f(char   *)隐藏了。由于数字   10   不能被隐式地转化为字符串,所以在编译时出错。

class   Base
...{
public:
        void   f(int   x);
};

class   Derived   :   public   Base
...{
public:
        void   f(char   *str);
};

void   Test(void)
...{
        Derived   *pd   =   new   Derived;
        pd-> f(10);   //   error
}

示例   3   由于隐藏而导致错误

从示例   3   看来,隐藏规则似乎很愚蠢。但是隐藏规则至少有两个存在的理由:
写语句   pd-> f(10)的人可能真的想调用   Derived::f(char   *)函数,只是他误将参数写错了。有了隐藏规则,编译器就可以明确指出错误,这未必不是好事。否则,编译器会静悄悄地将错就错,程序员将很难发现这个错误,流下祸根。
假如类   Derived   有多个基类(多重继承)   ,有时搞不清楚哪些基类定义了函数   f。如果没有隐藏规则,那么   pd-> f(10)可能会调用一个出乎意料的基类函数   f。尽管隐藏规则看起来不怎么有道理,但它的确能消灭这些意外。
示例   3   中,如果语句   pd-> f(10)一定要调用函数   Base::f(int),那么将类   Derived修改为如下即可。

class   Derived   :   public   Base
...{
public:
        void   f(char   *str);
        void   f(int   x)   ...{   Base::f(x);   }
};  

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值