函数重载、重写、重定义的对比

重载
函数重载是指在一个类中声明了多个名称相同但参数列表不同的函数，这些参数可能个数、顺序、类型不同，不能靠返回值类型来判断。
特征：

• 在同一个作用域中；
• 函数的名字相同；
• 参数不同；
• 返回值可以不同；
• 函数重载与virtual修饰无关；

---

函数重写（也称覆盖）
函数重载是指子类重新定义基类的虚函数。
特征：

• 不在同一作用域（分别位于基类和派生类）；
• 函数名字相同；
• 参数相同
• 返回值相同，否则会出错；
• 基类和派生类必须是虚函数，派生类virtual可不加，派生类的访问权限可以和基类的访问权限不一样，基类中的虚函数的访问权限必须是public；
• 重写函数的访问修饰符可以不同；

---

重定义（又称隐藏）
特征：

• 不在同一个作用域（分别位于基类和派生类中）；
• 函数名字相同；
• 返回值可以不同；
• 参数不同
• 参数不同；此时，不论有无 virtual 关键字，基类的函数将被隐藏（注意别与重载以及重写混淆）；
• 参数相同；但是基类函数没有 virtual关键字，此时，基类的函数被隐藏（注意别与重写混淆）；
• 两个基类和派生类的同名函数不构成重写、就是重定义；

---

例：

#include <iostream>
using namespace std;
 
class Base
{
public:
	/*  1.子类和父类返回值参数相同，函数名相同，有/无virtual关键字 */
	//	若无virtual关键字，则在子类中声明与父类同名的方法，从而覆盖了父类的方法（函数重定义）
	void a() 
	{
		cout << "Base::a()" << endl;
	};
 
	// 若有virtual关键字，即为虚函数。由对象的类型决定调用哪个函数（多态，函数重写override）。
	virtual void b()
	{
		cout << "Base::b()" << endl;
	}
 
    /*  2.子类和父类返回值参数不同，函数名相同，有/无virtual关键字  */
	// 若无virtual关键字，父类的同名成员被隐藏。
	void d(int x)
	{
		cout << "Base::d() x = " << x << endl;
	}
 
	// 若有virtual关键字，父类的同名成员同样被隐藏。
	virtual void e(int x)
	{
		cout << "Base::e() x = " << x << endl;
	}
 
	/*  3.子类和父类返回值参数相同，函数名相同，函数返回值不同，有/无virtual关键字 */
	// 若无virtual关键字（函数重写，这种情况不属于“函数重载”范畴）
	void f()
	{
		cout << "void Base::f()" << endl;
	}
 
	// 若有virtual关键字 (报错）
	virtual void g()
	{
		cout << "virtual void Base::g()" << endl;
	}
};
 
class Derived : public Base
{
public:
	/*  1.子类和父类返回值参数相同，函数名相同，有/无virtual关键字 */
	//	覆盖了父类同名方法（函数重写）
	void a() 
	{
		cout << "Derived::a()" << endl;
	}
 
	// 多态
	virtual void b()
	{
		cout << "Derived::b()" << endl;
	}
 
	/*  2.子类和父类返回值参数不同，函数名相同，有/无virtual关键字（注：函数重载与virtual关键字有无没有关系） */
	// 父类同名成员被隐藏
	void d(int x, int y)
	{
		cout << "Derived::d() x = " << x << " y = " << y<< endl;
	}
 
	// 父类同名成员被隐藏
	virtual void e(int x, int y)
	{
		cout << "Derived::e() x = " << x << " y = " << y << endl;
	}
 
	/*  3.子类和父类返回值参数相同，函数名相同，函数返回值不同，有/无virtual关键字 */
	// 返回值与基类不同
	int f()
	{
		cout << "int Derived::f()" << endl;
		return 1;
	}
 
	 error
	//virtual int g()
	//{
	//	cout << "virtual int Base::g()" << endl;
	//	return 1;
	//}
};
 
int main()
{
	// 用作参数
	int xx = 100;
 
	cout << "子类和父类返回值参数相同，函数名相同，无virtual关键字" << endl;
	Derived d;
	d.a();		
	d.Base::a();	// 显示调用基类方法
	cout << "子类和父类返回值参数相同，函数名相同，有virtual关键字" << endl;
	Base* b = new Derived;
	b->b();
	cout << "子类和父类返回值参数不同，函数名相同，无virtual关键字" << endl;
	d.d(xx, xx);
	// d.d(xx); // 报错
	d.Base::d(xx); // 显示调用
	cout << "子类和父类返回值参数不同，函数名相同，有virtual关键字" << endl;
	d.e(xx, xx);
	//d.e(xx); // error
	d.Base::e(xx);
	cout << "子类和父类返回值参数相同，函数名相同，函数返回值不同, 无virtual关键字" << endl;
	d.f();
	d.Base::f();
}

---