令人迷惑的隐藏规则

转自高质量C++/C编程指南

　本来仅仅区别重载与覆盖并不算困难，但是Ｃ＋＋的隐藏规则使问题复杂性陡然增加。
这里“隐藏”是指派生类的函数屏蔽了与其同名的基类函数，规则如下：　
（１）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无ｖｉｒｔｕａｌ
关键字，基类的函数将被隐藏（注意别与重载混淆）。　
（２）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有ｖｉｒｔｕａｌ
关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）。　
　示例程序８－２－２（ａ）中：　
（１）函数Ｄｅｒｉｖｅｄ：：ｆ（ｆｌｏａｔ）覆盖了Ｂａｓｅ：：ｆ（ｆｌｏａｔ）。　
（２）函数Ｄｅｒｉｖｅｄ：：ｇ（ｉｎｔ）隐藏了Ｂａｓｅ：：ｇ（ｆｌｏａｔ），而不是重载。　
（３）函数Ｄｅｒｉｖｅｄ：：ｈ（ｆｌｏａｔ）隐藏了Ｂａｓｅ：：ｈ（ｆｌｏａｔ），而不是覆盖
＃ｉｎｃｌｕｄｅ　＜ｉｏｓｔｒｅａｍ．ｈ＞　
　ｃｌａｓｓ　Ｂａｓｅ　
｛　
ｐｕｂｌｉｃ：　
　ｖｉｒｔｕａｌ　ｖｏｉｄ　ｆ（ｆｌｏａｔ　ｘ）｛　ｃｏｕｔ　＜＜　＂Ｂａｓｅ：：ｆ（ｆｌｏａｔ）　＂　＜＜　ｘ　＜＜　ｅｎｄｌ；　｝　
 ｖｏｉｄ　ｇ（ｆｌｏａｔ　ｘ）｛　ｃｏｕｔ　＜＜　＂Ｂａｓｅ：：ｇ（ｆｌｏａｔ）　＂　＜＜　ｘ　＜＜　ｅｎｄｌ；　｝　
　　　ｖｏｉｄ　ｈ（ｆｌｏａｔ　ｘ）｛　ｃｏｕｔ　＜＜　＂Ｂａｓｅ：：ｈ（ｆｌｏａｔ）　＂　＜＜　ｘ　＜＜　ｅｎｄｌ；　｝　
｝；　
ｃｌａｓｓ　Ｄｅｒｉｖｅｄ　：　ｐｕｂｌｉｃ　Ｂａｓｅ　
｛　
ｐｕｂｌｉｃ：　
　ｖｉｒｔｕａｌ　ｖｏｉｄ　ｆ（ｆｌｏａｔ　ｘ）｛　ｃｏｕｔ　＜＜　＂Ｄｅｒｉｖｅｄ：：ｆ（ｆｌｏａｔ）　＂　＜＜　ｘ　＜＜　ｅｎｄｌ；　｝　
 ｖｏｉｄ　ｇ（ｉｎｔ　ｘ）｛　ｃｏｕｔ　＜＜　＂Ｄｅｒｉｖｅｄ：：ｇ（ｉｎｔ）　＂　＜＜　ｘ　＜＜　ｅｎｄｌ；　｝　
　　　ｖｏｉｄ　ｈ（ｆｌｏａｔ　ｘ）｛　ｃｏｕｔ　＜＜　＂Ｄｅｒｉｖｅｄ：：ｈ（ｆｌｏａｔ）　＂　＜＜　ｘ　＜＜　ｅｎｄｌ；　｝　
｝；　

　据作者考察，很多Ｃ＋＋程序员没有意识到有“隐藏”这回事。由于认识不够深刻，“隐
藏”的发生可谓神出鬼没，常常产生令人迷惑的结果。　
 示例２（ｂ）中，ｂｐ和ｄｐ指向同一地址，按理说运行结果应该是相同的，可事
实并非这样。　
 　
ｖｏｉｄ　ｍａｉｎ（ｖｏｉｄ）　
｛　
 Ｄｅｒｉｖｅｄ　　ｄ；　
 Ｂａｓｅ　＊ｐｂ　＝　＆ｄ；　
 Ｄｅｒｉｖｅｄ　＊ｐｄ　＝　＆ｄ；　
／　Ｇｏｏｄ　：　ｂｅｈａｖｉｏｒ　ｄｅｐｅｎｄｓ　ｓｏｌｅｌｙ　ｏｎ　ｔｙｐｅ　ｏｆ　ｔｈｅ　ｏｂｊｅｃｔ　
ｐｂ－＞ｆ（３．１４ｆ）；　／／　Ｄｅｒｉｖｅｄ：：ｆ（ｆｌｏａｔ）　３．１４　　
ｐｄ－＞ｆ（３．１４ｆ）；　／／　Ｄｅｒｉｖｅｄ：：ｆ（ｆｌｏａｔ）　３．１４　

／／　Ｂａｄ　：　ｂｅｈａｖｉｏｒ　ｄｅｐｅｎｄｓ　ｏｎ　ｔｙｐｅ　ｏｆ　ｔｈｅ　ｐｏｉｎｔｅｒ　
ｐｂ－＞ｇ（３．１４ｆ）；　／／　Ｂａｓｅ：：ｇ（ｆｌｏａｔ）　３．１４　　
ｐｄ－＞ｇ（３．１４ｆ）；　／／　Ｄｅｒｉｖｅｄ：：ｇ（ｉｎｔ）　３　　　　　　　　（ｓｕｒｐｒｉｓｅ！）　

 ／／　Ｂａｄ　：　ｂｅｈａｖｉｏｒ　ｄｅｐｅｎｄｓ　ｏｎ　ｔｙｐｅ　ｏｆ　ｔｈｅ　ｐｏｉｎｔｅｒ　
 ｐｂ－＞ｈ（３．１４ｆ）；　／／　Ｂａｓｅ：：ｈ（ｆｌｏａｔ）　３．１４　　　　　　（ｓｕｒｐｒｉｓｅ！）　
 ｐｄ－＞ｈ（３．１４ｆ）；　／／　Ｄｅｒｉｖｅｄ：：ｈ（ｆｌｏａｔ）　３．１４　　
｝　

 

３　摆脱隐藏　
　隐藏规则引起了不少麻烦。示例３程序中，语句ｐｄ－＞ｆ（１０）的本意是想调用函
数Ｂａｓｅ：：ｆ（ｉｎｔ），但是Ｂａｓｅ：：ｆ（ｉｎｔ）不幸被Ｄｅｒｉｖｅｄ：：ｆ（ｃｈａｒ　＊）隐藏了。由于数字１０
不能被隐式地转化为字符串，所以在编译时出错。　
ｃｌａｓｓ　Ｂａｓｅ　
｛　
 ｐｕｂｌｉｃ：　
 ｖｏｉｄ　ｆ（ｉｎｔ　ｘ）；　
｝；　
ｃｌａｓｓ　Ｄｅｒｉｖｅｄ　：　ｐｕｂｌｉｃ　Ｂａｓｅ　
｛　
 ｐｕｂｌｉｃ：　
 ｖｏｉｄ　ｆ（ｃｈａｒ　＊ｓｔｒ）；　
｝；　
ｖｏｉｄ　Ｔｅｓｔ（ｖｏｉｄ）　
｛　
 Ｄｅｒｉｖｅｄ　＊ｐｄ　＝　ｎｅｗ　Ｄｅｒｉｖｅｄ；　
 ｐｄ－＞ｆ（１０）；　／／　ｅｒｒｏｒ　
｝　
 示例３　由于隐藏而导致错误　
  从示例３看来，隐藏规则似乎很愚蠢。但是隐藏规则至少有两个存在的理由：　
u 写语句ｐｄ－＞ｆ（１０）的人可能真的想调用Ｄｅｒｉｖｅｄ：：ｆ（ｃｈａｒ　＊）函数，只是他误将参数写错了。有了隐藏规则，编译器就可以明确指出错误，这未必不是好事。否则，编
  译器会静悄悄地将错就错，程序员将很难发现这个错误，流下祸根。　
u 假如类Ｄｅｒｉｖｅｄ有多个基类（多重继承），有时搞不清楚哪些基类定义了函数ｆ。如
  果没有隐藏规则，那么ｐｄ－＞ｆ（１０）可能会调用一个出乎意料的基类函数ｆ。尽管隐藏
  规则看起来不怎么有道理，但它的确能消灭这些意外。　
示例３中，如果语句ｐｄ－＞ｆ（１０）一定要调用函数Ｂａｓｅ：：ｆ（ｉｎｔ），那么将类
Ｄｅｒｉｖｅｄ修改为如下即可。　
ｃｌａｓｓ　Ｄｅｒｉｖｅｄ　：　ｐｕｂｌｉｃ　Ｂａｓｅ　
｛　
 ｐｕｂｌｉｃ：　
 ｖｏｉｄ　ｆ（ｃｈａｒ　＊ｓｔｒ）；　
 ｖｏｉｄ　ｆ（ｉｎｔ　ｘ）　｛　Ｂａｓｅ：：ｆ（ｘ）；　｝　
｝；