C++ 重载 重写


#include <cstdlib>
#include <iostream>

using namespace std;

//重载只放在在一个类里面 ,在编译期间就确定
class Parent
{
public:
	Parent()
	{
		cout << "Parent:printf()..do" << endl;
	}
public:
	void aaaaa()
	{
		;
	}
	void func()
	{
		cout << "Parent:void func()" << endl;
	}

	void func(int i)
	{
		cout << "Parent:void func(int i)" << endl;
	}

	virtual void func(int i, int j)
	{
		cout << "Parent:void func(int i, int j)" << endl;
	}
};

//重写 父子类之间,函数三要素(函数名、函数参数、函数返回类型)完全一样 
//重写又分为两种
//如果父类中有virtual关键字,这种父子之间的关系叫做虚函数重写,这种情况下发生多态 (动态链编 迟绑定)
//如果父类中没有virtual关键字,这种父子之间的关系 重定义  (静态链编)
class Child : public Parent
{

public:

	//此处2个参数,和子类func函数是什么关系
	void func(int i, int j)
	{
		cout << "Child:void func(int i, int j)" << " " << i + j << endl;
	}

	//我想在子类中重载父类的func函数  ====》
	//此处3个参数的,和子类func函数是什么关系
	void func(int i, int j, int k)
	{
		cout << "Child:void func(int i, int j, int k)" << " " << i + j + k << endl;
	}
};

void run01(Parent* p)
{
	p->func(1, 2);
}

int main()
{
	Parent p;

	p.func();
	p.func(1);
	p.func(1, 2);



	Child c;
	//c.func(); //注意1
	c.Parent::func();
	//c.aaaaa();
	//c.func(1, 2);

	run01(&p);
	run01(&c);

	return 0;
}

//问题1:child对象继承父类对象的func,请问这句话能运行吗?why
//c.func(); 

//1子类里面的func无法重载父类里面的func 
//2当父类和子类有相同的函数名、变量名出现,发生名称覆盖
//3//c.Parent::func();
//问题2 子类的两个func和父类里的三个func函数是什么关系?



### C++重载重写和覆盖的概念及区别 #### 1. 函数重载 (Function Overloading) 函数重载是指在同一个作用域内定义多个同名函数,但这些函数的参数列表(包括参数的个数、类型或顺序)必须不同。返回值类型的不同并不构成重载[^2]。例如: ```cpp class Example { public: void func(int a) {} // 参数为 int 类型 void func(double a) {} // 参数为 double 类型 void func(int a, int b) {} // 参数为两个 int 类型 }; ``` - **特点**: - 必须在同一作用域内。 - 参数列表必须不同。 - 返回值类型与重载无关。 #### 2. 函数重写 (Function Overriding) 函数重写是指在派生类中重新定义基类中的虚函数,要求函数名、参数列表和返回值类型相同。重写函数可以改变访问修饰符。例如: ```cpp class Base { public: virtual void func() {} // 基类中的虚函数 }; class Derived : public Base { public: void func() override {} // 派生类中的重写函数 }; ``` - **特点**: - 必须在派生类中定义。 - 基类函数必须是虚函数(`virtual`)。 - 参数列表和返回值类型必须一致。 - 访问修饰符可以不同。 #### 3. 函数覆盖 (Function Hiding) 函数覆盖是指派生类中的函数隐藏了基类中同名的函数。即使参数列表不同,基类中的函数也会被隐藏。例如: ```cpp class Base { public: void func() {} // 基类中的函数 }; class Derived : public Base { public: void func(int a) {} // 派生类中的函数,隐藏了基类的 func() }; ``` - **特点**: - 只要函数名相同,无论参数列表是否不同,基类函数都会被隐藏。 - 使用作用域运算符(`::`)可以调用被隐藏的基类函数。 #### 区别与联系 | 特性 | 函数重载 | 函数重写 | 函数覆盖 | |---------------------|--------------------------|--------------------------|--------------------------| | **作用域** | 同一作用域 | 基类与派生类之间 | 基类与派生类之间 | | **参数列表** | 必须不同 | 必须相同 | 不一定相同 | | **返回值类型** | 无关 | 必须相同或协变 | 无关 | | **虚函数要求** | 不需要 | 基类函数必须为虚函数 | 不需要 | | **访问修饰符** | 无关 | 可以不同 | 无关 | #### 示例代码 以下代码展示了重载重写和覆盖的区别: ```cpp #include <iostream> using namespace std; class Base { public: virtual void func() { cout << "Base::func()" << endl; } // 虚函数 void func(int x) { cout << "Base::func(int)" << endl; } // 非虚函数 }; class Derived : public Base { public: void func() override { cout << "Derived::func()" << endl; } // 重写 void func(int x) { cout << "Derived::func(int)" << endl; } // 覆盖 void func(double x) { cout << "Derived::func(double)" << endl; } // 重载 }; int main() { Derived d; Base* b = &d; b->func(); // 调用 Derived::func()(重写) d.func(1); // 调用 Derived::func(int)(覆盖) d.func(1.0); // 调用 Derived::func(double)(重载) return 0; } ``` ### 输出结果 ``` Derived::func() Derived::func(int) Derived::func(double) ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值