c++类的隐藏，覆盖和重载，using关键字使用

转载一篇文章：

http://www.cnblogs.com/ustc11wj/archive/2012/08/11/2637316.html

类的隐藏和重载不一样

类的隐藏是指

一个类继承自另外一个类，则父类中与子类名称相同的函数将被隐藏，不管父类中这个函数重载了几次，子类中将不再能够使用它们。

更详细的解释是：

http://www.cnblogs.com/renyuan/archive/2013/06/08/3127562.html

1 重载与覆盖

成员函数被重载的特征：

（1）相同的范围（在同一个类中）；

（2）函数名字相同；

（3）参数不同；

（4）virtual关键字可有可无。

覆盖是指派生类函数覆盖基类函数，特征是：

（1）不同的范围（分别位于派生类与基类）；

（2）函数名字相同；

（3）参数相同；

（4）基类函数必须有virtual关键字。

令人迷惑的隐藏规则
本来仅仅区别重载与覆盖并不算困难，但是C++的隐藏规则使问题复杂性陡然增加。这里“隐藏”是指派生类的函数屏蔽了与其同名的基类函数，规则如下：
（1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆）。
（2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）。

编程实验：

#include <iostream>
using namespace std;
class A
{
	public:
		void printfSth()
		{
			cout<<"A::printfsth()"<<endl;
		}
		void printfSth(string str)
		{

			cout<<"A::printfsth(string str):"<<str<<endl;
		}
		void printfSth(int i)
		{
			cout<<"A::virtual printfSth(int i):"<<i<<endl;

		}

};
class C:public A
{
	public:
		using A::printfSth;
		void printfSth(double i)
		{
			cout<<"C::printfSth(double i):"<<i<<endl;

		}

};

int main()
{

	C* c=new C();
	c->printfSth();
	c->printfSth(1);
	c->printfSth(1.1);
	delete c;

}

　　这个时候就能够有输出，因为用了using关键字

还有另外一个用法

#include <iostream>
using namespace std;
class A
{
	public:
		void printfSth()
		{
			cout<<"A::printfsth()"<<endl;
		}
		void printfSth(string str)
		{

			cout<<"A::printfsth(string str):"<<str<<endl;
		}
		void printfSth(int i)
		{
			cout<<"A::virtual printfSth(int i):"<<i<<endl;

		}

};
class C:private A
{
	public:
		using A::printfSth;
};

int main()
{

	C* c=new C();
	c->printfSth();
	c->printfSth(1);
	c->printfSth(1.1);
	delete c;

}

　　这个时候还是能够用A中方法。