重写 重载 隐藏

本文详细解析了C++中的重载、重写及隐藏的概念,并通过示例代码进行了说明。介绍了如何区分这三种不同的行为,以及它们在实际编程中的应用。

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

C++中有很多概念,很容易混淆,下面主要来说一下重载,重写和隐藏的区别:

重载:overload  --函数名一样,函数的参数不同(包括参数的个数,参数的类型),返回值没有要求:

重写:override --函数名称,参数,返回值一样(返回值仅限父类和子类的时候不一样);

隐藏:hide--重载的函数放在子类和父类中就会形成隐藏:

#include <iostream>
using namespace std;
void aa(int a )   //函数的重载,函数名称相同,函数参数不一样,根据参数的个数来调用函数;
{
	cout<<"aa"<<endl;
}

void aa(int a,int b)
{
	cout<<a<<b<<endl;
}

class father
{
public:
	void show()
	{
		cout<<"this is the father"<<endl;
	}
	void cc()
	{
		cout<<"this is the father cc"<<endl;
	}
};

class son :public father
{
public:
	void show()  //重写父类的show函数;名称参数一样,功能不一样;
	{
		cout<<"this is the son show"<<endl;
	}

	void cc(int a ,int b) //隐藏不能根据函数的参数来调用函数,只能用对象或者类名+::作用域来调用;
	{					//把father中的cc隐藏了;
		cout<<"this is the son cc"<<endl;
	}


};
int main()
{
	son s;
	s.father::cc();  //类名+ ::来调用隐藏的函数;
	s.cc(100,200);
	s.show();
	s.father::show();
	system("pause");
	return 0;
}

重载只是一种语言特性,与多态无关,因为它是在编译期间就进行了函数的绑定,也就是静态绑定,属于早绑定!早绑定与静态绑定与多态和面向对象无关!

void fun(int a);

void fun(int a, char *b);

经过编译后,在编译期间可能处理为:i_fun()和char_fun(),这样的标示和绑定!!

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

余额充值