C++ overload(重载) overrriding(重写 or 覆盖) redefine(重定义)浅析

#include "stdafx.h"
#include "iostream"
#include "stdio.h"
#include <string>

using namespace std;

class Base{
public:
	void f( int ){
		cout << "Base::void f( int )" << endl;
	}
	void f(string ){	// overload 参数不同，可以重载
		cout << "Base::void f( string )" << endl;
	}
	/*
	int f( int ){ }     //不能通过返回值overload
	*/
	virtual void g ( int ){
		cout << "Base::virtual void g( int )" << endl;
	}
	virtual void g( ){
		cout << "Base::virtual void g(  )" << endl;
	}
};


class Derived1: public Base{
public:
	int f( int ){		//可以通过返回值redefining
		cout << "Derived::int f( int )" << endl;
		return 1;
	}
	void g( int ){		// overriding
		cout << "Derived::void g( int )" << endl;
	}
	void g( string ){	// redefine
		cout << "Derived::void g( sting )" << endl;
	}
	/*   error    返回值与Base的g()不同,编译期间报错  \
				与f函数不同，g是虚函数，故不能redefine
	int g( int ){
		cout << "Derived::int g( int )";
		return 1;
	}
	*/

	/*	error    返回值与Base的g()不同
	int g() {
		cout << "Derived::int g( )";
		return 1;
	}
	*/
};

int main( ){

	class Derived1 d1;

	int x = d1.f(1);		//调用子类的f，返回int
	// Derived::int f( int )

	//	d1.f("abc");		error!  Name hiding

	d1.g( 1 );
	//Derived::void g( int )

	d1.Base::g(1);
	//Base::virtual void g( int )

	d1.g("abc");
	//Derived::void g( sting )

	//	d1.g();				error!	Name hiding

	class Base* pb;
	pb = &d1;

	pb->f( "abc" );
	//Base::void f( string )

	pb->f( 1 );
	//Base::void f( int )

	pb->g( );
	//Base::virtual void g(  )

	pb->g( 1 );
	//Derived::void g( int )

	//	pb->g( "abc" );		error!   子类中定义
}