Effective_C++_条款三十三：避免遮掩继承而来的名称

首先理解下成员函数的重载、覆盖（override）与隐藏

重载与覆盖

成员函数被重载的特征：
（1）相同的范围（在同一个类中）；
（2）函数名字相同；
（3）参数不同；
（4）const函数或者指向const的指针

#include<iostream>
using namespace std;


class Base
{
public:
	virtual void function()
	{
	}
	//void function()//这个函数被看做和前一个函数相同，virtual不能被看做重载的条件
	//{
	//}
	//int function()//这个函数被看做和前一个函数相同，不同的返回类型不能被看做重载的条件
	//{
	//}
	//const void function()//这个函数被看做和前一个函数相同，const的返回类型不能被看做重载的条件
	//{
	//}
	void function(int i)
	{

	}
	void function(const int *i)
	{

	}
	void function(int *i)
	{

	}
	//void function(int const *i)//这个函数被看做和void function(int *i)相同，常指针不能被看做重载的条件
	//{
	//}
	void function(int i)const
	{

	}
};


int main()
{
	Base b;
	b.function(1);// call void function(int i)


	const Base cb;
	cb.function(1);//call void function(int i)const
	return 0;
}

覆盖是指派生类函数覆盖基类函数，特征是：
（1）不同的范围（分别位于派生类与基类）；
（2）函数名字相同；
（3）参数相同，返回类型一致（返回类型不同，编译无法通过）；

'Derived::function': overriding virtual function return type differs and is not covariant from 'Base::function'

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

#include<iostream>
using namespace std;


class Base
{
public:
	virtual void function()
	{
	}
	//void function()//这个函数被看做和前一个函数相同，virtual不能被看做重载的条件
	//{
	//}
	//int function()//这个函数被看做和前一个函数相同，不同的返回类型不能被看做重载的条件
	//{
	//}
	//const void function()//这个函数被看做和前一个函数相同，const的返回类型不能被看做重载的条件
	//{
	//}
	void function(int i)
	{

	}
	void function(const int *i)
	{

	}
	void function(int *i)
	{

	}
	//void function(int const *i)//这个函数被看做和void function(int *i)相同，常指针不能被看做重载的条件
	//{
	//}
	void function(int i)const
	{

	}
};

class Derived :public Base
{
	void function()
	{

	}
};

int main()
{
	Base b;
	b.function(1);// call void function(int i)


	const Base cb;
	cb.function(1);//call void function(int i)const

	Derived d;
	Base *bb;
	bb = &d;
	bb->function();//call void Derived::function()
	return 0;
}

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

名称的遮掩可以分成变量的遮掩与函数的遮掩两类，本质都是名字的查找方式导致的，当编译器要去查找一个名字时，它一旦找到一个相符的名字，就不会再往下去找了，因此遮掩本质上是优先查找哪个名字的问题。

而查找是分作用域的，虽然本条款的命名是打着“继承”的旗子来说的，但我觉得其实与继承并不是很有关系，关键是作用域。

//例1：普通变量遮掩
int i = 3;

int main()
{
    int i = 4;
    cout << i << endl; // 输出4
}

这是一个局部变量遮掩全局变量的例子，编译器在查找名字时，优先查找的是局部变量名，找到了就不会再找，所以不会有warning，不会有error，只会是这个结果。

//例2：成员变量遮掩
class Base
{
public:
    int x;
    Base(int _x):x(_x){}
};

class Derived: public Base
{
public:
    int x;
    Derived(int _x):Base(_x),x(_x + 1){}
};

int main()
{
    Derived d(3);
    cout << d.x << endl; //输出4
}

因为定义的是子类的对象，所以会优先查找子类独有的作用域，这里已经找到了x，所以不会再查找父类的作用域，因此输出的是4，如果子类里没有另行声明x成员变量，那么才会去查找父类的作用域。那么这种情况下如果想要访问父类的x，怎么办呢？

可以在子类里面添加一个方法：

int GetBaseX() {return Base::x;}