【C++拾遗】 C++函数重载、重写、重定义的区别

原创作品，转载请标明：http://blog.csdn.net/xiejingfa/article/details/48496593

函数重载（overload）
函数重载是指在一个类中声明多个名称相同但参数列表不同的函数，这些的参数可能个数或顺序，类型不同，但是不能靠返回类型来判断。特征是：
（1）相同的范围（在同一个作用域中）；
（2）函数名字相同；
（3）参数不同；
（4）virtual 关键字可有可无（注：函数重载与有无virtual修饰无关）；
（5）返回值可以不同；

函数重写（也称为覆盖 override）
函数重写是指子类重新定义基类的虚函数。特征是：
（1）不在同一个作用域（分别位于派生类与基类）；
（2）函数名字相同；
（3）参数相同；
（4）基类函数必须有 virtual 关键字，不能有 static 。
（5）返回值相同，否则报错；
（6）重写函数的访问修饰符可以不同；

重定义（也称隐藏）
（1）不在同一个作用域（分别位于派生类与基类） ；
（2）函数名字相同；
（3）返回值可以不同；
（4）参数不同。此时，不论有无 virtual 关键字，基类的函数将被隐藏（注意别与重载以及覆盖混淆）；
（5）参数相同，但是基类函数没有 virtual关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）；

例子

#include <iostream>
using namespace std;

class Base
{
public:
	// =========================================================================
	//  子类和父类返回值参数相同，函数名相同，有/无virtual关键字
	// =========================================================================
	
	//	若无virtual关键字，则在子类中声明与父类同名的方法，从而覆盖了父类的方法（函数重定义）
	void a() 
	{
		cout << "Base::a()" << endl;
	};

	// 若有virtual关键字，即为虚函数。由对象的类型决定调用哪个函数（多态，函数重写override）。
	virtual void b()
	{
		cout << "Base::b()" << endl;
	}

	// =========================================================================
	//  子类和父类返回值参数不同，函数名相同，有/无virtual关键字 
	// =========================================================================

	// 若无virtual关键字，父类的同名成员被隐藏。
	void d(int x)
	{
		cout << "Base::d() x = " << x << endl;
	}

	// 若有virtual关键字，父类的同名成员同样被隐藏。
	virtual void e(int x)
	{
		cout << "Base::e() x = " << x << endl;
	}

	// =========================================================================
	//  子类和父类返回值参数相同，函数名相同，函数返回值不同，有/无virtual关键字
	// =========================================================================

	// 若无virtual关键字（函数重写，这种情况不属于“函数重载”范畴）
	void f()
	{
		cout << "void Base::f()" << endl;
	}

	// 若有virtual关键字 (报错）
	virtual void g()
	{
		cout << "virtual void Base::g()" << endl;
	}
};

class Derived : public Base
{
public:
	// =========================================================================
	//  子类和父类返回值参数相同，函数名相同，有/无virtual关键字
	// =========================================================================

	//	覆盖了父类同名方法（函数重写）
	void a() 
	{
		cout << "Derived::a()" << endl;
	}

	// 多态
	virtual void b()
	{
		cout << "Derived::b()" << endl;
	}

	// =========================================================================
	//  子类和父类返回值参数不同，函数名相同，有/无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;
	}

	// =========================================================================
	//  子类和父类返回值参数相同，函数名相同，函数返回值不同，有/无virtual关键字
	// =========================================================================

	// 返回值与基类不同
	int f()
	{
		cout << "int Derived::f()" << endl;
		return 1;
	}

	 错误
	//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); // 报错
	d.Base::e(xx);
	cout << "子类和父类返回值参数相同，函数名相同，函数返回值不同, 无virtual关键字" << endl;
	d.f();
	d.Base::f();
}

输出：