33：避免遮掩继承而来的名称

我们都知道在下面的代码中：

int x;//global变量
void someFunc()
{
	double x;//local变量
	cin >> x;//读一个新值赋予local变量x
}

上述读取数据的语句指涉的是local变量x，而不是global变量x，因为内层作用域的名称会遮掩外围作用域的名称。

当编译器处于someFunc的作用域内并遭遇名称x时，它在local作用域内查找是否有什么东西带着这个名称。若找到就不再找其他作用域。

本例的someFunc的x是double类型而global x是int类型，但那不要紧。

C++的名称遮掩规则（name-hiding rules）所做的唯一事情就是：遮掩名称。

至于名称是否应该为相同或不同的类型，并不重要。

结果是，本例中一个名为x的double遮掩了一个名为x的int。

现在导入继承，当位于一个derived class成员函数内指涉base class内的某物（也许是个成员函数、typedef、或成员变量）时，编译器可以找出我们所指涉的东西，因为derived class继承了声明于base class内的所有东西，实际运作方式是，derived class作用域被嵌套在base class作用域内，像这样：

class Base {
private:
	int x;
public:
	virtual void mf1() = 0;
	virtual void mf2();
	void mf3();
	//...
};
class Derived : public Base {
public:
	virtual void mf1();
	void mf4();
	//...
};

假设derived class内的mf4的实现码部分像这样：

void Derived::mf4()
{
	//...
	mf2();
	//...
}

 当编译器看到这里使用名称mf2，必须估算它指涉什么东西。

编译器的做法是查找各作用域，看看有没有某个名为mf2的声明式。

首先查找local作用域（也就是mf4所覆盖的作用域），在那没找到任何东西名为mf2。于是查找其外围作用域，也就是class Derived覆盖的作用域。还是没找到任何东西名为mf2，于是再往外围移动，本例为base class。在那编译器找到一个名为mf2的东西，于是停止查找。若Base内还是没有mf2，查找动作便继续下去，首先找内含Base的那个namespace的作用域（若有的话），最后往global作用域找去。

现在再考虑前一个例子，这次重载mf1和mf3，并且添加一个新版mf3到Derived去。

这里发生的事情是：

Derived重载了mf3，那是一个继承而来的non-virtual函数。这会使整个设计立刻显得疑云重重。

class Base {
private:
	int x;
public:
	virtual void mf1() = 0;
	virtual void mf1(int);
	virtual void mf2();
	void mf3();
	void mf3(double);
	//...
};
class Derived : public Base {
public:
	virtual void mf1();
	void mf3();
	void mf4();
	//...
};

以作用域为基础的“名称遮掩规则”并没有改变，因此base class内所有名为mf1和mf3的函数都被derived class内的mf1和mf3函数遮掩掉了。从名称查找观点来看，Base::mf1和Base::mf3不再被Derived继承。

Derived d;
int x;
//...
d.mf1();//没问题，调用Derived::mf1
d.mf1(x);//错误，因为Derived::mf1遮掩了Base::mf1
d.mf2();//没问题，调用Base::mf2
d.mf3();//没问题，调用Derived::mf3
d.mf3(x);//错误，因为Derived::mf3遮掩了Base::mf3

上述规则依然适用，即使base class和derived class内的函数有不同的参数类型也适用，而且无论函数是virtual或non-virtual一体适用。

这些行为背后的基本理由是为了防止你在程序库或应用框架(qpplication framwork）内建立新的derived class时附带地从疏远的base class继承重载函数。

若想使用通过继承被遮掩的函数，可以适用using声明式：

class Base {
private:
	int x;
public:
	virtual void mf1() = 0;
	virtual void mf1(int);
	virtual void mf2();
	void mf3();
	void mf3(double);
	//...
};
class Derived : public Base {
public:
	using Base::mf1;
	//让Base class内名为mf1和mf3的所有东西，
	//在Derived作用域内都可见（并且public）
	using Base::mf3;
	virtual void mf1();
	void mf3();
	void mf4();
	//...
};

现在，继承机制将一如往昔地运作：

Derived d;
int x;
//...
d.mf1();//没问题，调用Derived::mf1
d.mf1(x);//现在没问题，调用Base::mf1
d.mf2();//没问题，调用Base::mf2
d.mf3();//没问题，调用Derived::mf3
d.mf3(x);//现在没问题，调用Base::mf3

这意味着若你继承base class并加上重载函数，而你又希望重新定义或覆写（推翻）其中一部分，那么你必须为哪些原本会被遮掩的每个名称引入一个using声明式，否则某些你希望继承的名称会被遮掩。

假设Derived以private形式继承Base，而Derived唯一想继承的mf1是那个无参数版本。using声明式在这里派不上用场，因为using声明式会令继承而来的某给定名称的所有同名函数在derived class中都可见。

这时我们需要的是不同的技术，即一个简单的转交函数（forwarding function）：

class Base {
private:
	int x;
public:
	virtual void mf1() = 0;
	virtual void mf1(int);
	//...//与前同
};
class Derived : private Base {
public:
	//转交函数，暗自成为inline
	virtual void mf1()
	{
		Base::mf1();
	}
	//...
};
Derived d;
int x;
//...
d.mf1();//没问题，调用Derived::mf1
d.mf1(x);//错误，Base::mf1被遮掩了

inline转交函数的另一个用途是为那些不支持using声明式（但，这并非正确行为）的老旧编译器另辟一条新路，将继承而得的名称汇入derived class作用域内。

总结

1.derived class内的名称会遮掩base class内的名称。在public继承下从来没有人希望如此。

2.为了让被遮掩的名称再见天日，可使用using声明式或转交函数。