#include <cstdio>
#include <cstdlib>

class Base
{
public:
#pragma region MyRegion1
	
	//函数重载(overload)
	//step1:在同一个类中
	//step2:函数名相同；
	//step3:参数不同；
	//step4:virtual 关键字可有可无
	void overload_fun(int x,int y)
	{
		printf("Base::overload_fun(int x,int y)  %d  %d\n",x,y);
	}
	void overload_fun(int x)
	{
		printf("Base::overload_fun(int x)  %d\n",x);
	}
	//end

#pragma endregion

#pragma region MyRegion2
	
	//函数覆盖(override)：指派生类函数覆盖基类函数
	//step1:不同的范围（分别位于派生类与基类）；
	//step2:函数名相同；
	//step3:参数相同；
	//step4:基类函数必须有virtual 关键字。
	virtual void override_fun(int x,int y,int z)
	{
		printf("Base::override_fun()  x=%d  y=%d  z=%d\n",x,y,z);
	}
	//end

#pragma endregion

#pragma region MyRegion3

	//函数重写(overwrite):指派生类的函数屏蔽了与其同名的基类函数
	//第一种
	//step1:函数名与基类相同；
	//step2:参数不同；
	//step3:无论有无virtual 基类函数将被隐藏。
	void overwrite_fun1(int x,int y)
	{
		printf("Base::overwrite_fun1(int x,int y)  x=%d  y=%d\n",x,y);
	}

	//函数重写(overwrite)第二种
	//step1:函数名与基类相同；
	//step2:参数相同；
	//step3:无virtual 基类函数将被隐藏。  
	//注意区别于函数覆盖(override)
	void overwrite_fun2(int x,int y)
	{
		printf("Base::overwrite_fun2(int x,int y)  x=%d  y=%d\n",x,y);
	}
	//end

#pragma endregion
} ;

class Derived : public Base
{
public:
	//函数覆盖(override)
	virtual void override_fun(int x,int y,int z)  override{
		printf("Derived::override_fun() x=%d  y=%d  z=%d\n",x,y,z);
	}

	//函数重写 第一种
	void overwrite_fun1(int x)
	{
		printf("Derived::overwrite_fun1(int x)  x=%d\n",x);
	}
	//函数重写 第二种
	void overwrite_fun2(int x,int y)
	{
		printf("Derived::overwrite_fun2(int x,int y)  x=%d  y=%d\n",x,y);
	}
} ;
int main(int agrc,char* agrv[])
{
	printf("=============================================\n");
	//测试函数覆盖 
	Base* pBase = new Derived();
	pBase->override_fun(1,2,3);
	printf("=============================================\n");

	printf("=============================================\n");
	//测试函数重写第一种情况,参数不同 
	Derived der;
	der.overwrite_fun1(1);
	//基类同名函数被隐藏
	//调用基类同名函数
	der.Base::overwrite_fun1(1,2);
	printf("=============================================\n");


	printf("=============================================\n");
	//测试函数重写第二种情况
	der.overwrite_fun2(1,2);
	//基类同名函数被隐藏
	//调用基类同名函数
	der.Base::overwrite_fun2(1,2);
	printf("=============================================\n");

	system("PAUSE");
	return 0;
}

运行结果：

补充说明,网上摘录:

Overload(重载)：在C++程序中，可以将语义、功能相似的几个函数用同一个名字表示，但参数或返回值不同（包括类型、顺序不同），即函数重载。
（1）相同的范围（在同一个类中）；
（2）函数名字相同；
（3）参数不同；
（4）virtual 关键字可有可无。

Override(覆盖)：是指派生类函数覆盖基类函数，特征是：
（1）不同的范围（分别位于派生类与基类）；
（2）函数名字相同；
（3）参数相同；
（4）基类函数必须有virtual 关键字。

Overwrite(重写)：是指派生类的函数屏蔽了与其同名的基类函数，规则如下：
（1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆）。

（2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）。