<<Exceptional C++>>条款21的一个疑问

zuiwei

条款21: GotW#5 改写虚拟函数(Overriding Virtual Functions)

里面说到: 重载解析程序(overload resolution)是根据静态类型完成的，而不是根据动态类型完成的，所以pb->f(1.0)实际上应该调用Base::f

但是我编程实现，发现调用的是child::f啊。难道书上有误，还是我程序有误?

1. 
   
2. #include<stdio.h>
   
3. struct base{
   
4.     virtual void f(int){printf("%s\n",__FUNCTION__);}
   
5.     virtual void f(float){printf("%s\n",__FUNCTION__);}
   
6.     virtual void g(int){printf("%s\n",__FUNCTION__);}
   
7.     virtual ~base(){}
   
8. };
   
9. struct child: base{
   
10.     void f(float){printf("%s\n",__FUNCTION__);}
    
11.     void g(int){printf("%s\n",__FUNCTION__);}
    
12. };
    
13. 
    
14. int main(void)
    
15. {
    
16.     base* pb=new child;
    
17.     pb->f(1.0f);
    
18.     pb->f(1);
    
19.     pb->g(1);
    
20.     delete pb;
    
21.         return 0;
    
22. }
    

复制代码

liwangli1983

using这事和你那个问题没关系，using是这样的，见代码:

1. 
   
2. #include<cstdio>
   
3. struct base{
   
4.     void f(int){puts("base f");}
   
5. };
   
6. 
   
7. struct child: base{
   
8.     void f(float){puts("child f");}
   
9. };
   
10. 
    
11. int main(void)
    
12. {
    
13.     child c;
    
14.     c.f(2);
    
15.     return 0;
    
16. }
    

复制代码

这时打印的会是"child f"，因为child f覆盖base f。
但如果把child里加上using

1. struct child: base{
   
2.     using base::f;
   
3.     void f(float){puts("child f");}
   
4. };

复制代码

就会打印出"base f"
using可以使base中的函数参与到重载解析中。

gtkmm

必须是child:f(float)啊，
道友还有什么疑问的？？

要么你把那些virtual去掉，就是base::f(float)了．

幻の上帝

base和child里都有f，除非using base::f;，base里的被child里的隐藏了，实际参与重载解析的只有child::f。
直接写pb->base::f(1.0)就没问题了。

（回帖手残点到编辑了，改回原样。。）

starwing83

我觉得你是理解错了，看看这个程序：

1. #include <iostream>
   
2. #include <complex>
   
3. 
   
4. struct B {
   
5.     virtual ~B() {}
   
6.     virtual void f(double) { std::cout << "double f\n"; }
   
7. };
   
8. 
   
9. struct D : public B {
   
10.     virtual void f(int) { std::cout << "int f\n"; }
    
11.     virtual void f(std::complex<double>) { std::cout << "complex f\n"; }
    
12. };
    
13. 
    
14. int main(void)
    
15. {
    
16.     B *pd = new D;
    
17.     pd->f(1);
    
18.     delete pd;
    
19.     return 0;
    
20. }
    

复制代码

作者的意思是，这个程序应该打印出double f，因为即使pd实际上指向了一个D（拥有接受int参数的f），但是因为重载解析是在编译期完成的，所以编译器实际上只看得到静态类型B*里面具有的方法，也就是一个唯一的double f，也就只会调用这个了，而不是去调用那个看上去“更适合”的int f。

zuiwei

幻の上帝 发表于 2012-05-02 18:53
base和child里都有f，除非using base::f;，base里的被child里的隐藏了，实际参与重载解析的只有child::f。
...

这个using base::f;应该写在哪里? 我写在child类里面发现还是不行啊:

1. 
   
2. 
   
3. struct base{
   
4.     virtual void f(int){printf("%s\n",__FUNCTION__);}
   
5.     virtual void f(float){printf("%s\n",__FUNCTION__);}
   
6.     virtual void g(int){printf("%s\n",__FUNCTION__);}
   
7.     virtual ~base(){}
   
8. };
   
9. struct child: base{
   
10.     using base::f;
    
11.     void f(float){printf("%s\n",__FUNCTION__);}
    
12.     void g(int){printf("%s\n",__FUNCTION__);}
    
13. };
    
14. 
    
15. int main(void)
    
16. {
    
17.     base* pb=new child;
    
18.     pb->f(1.0f);
    
19.     pb->g(1);
    
20.     delete pb;
    
21.         return 0;
    
22. }
    

复制代码

bruceteen

我写在child类里面发现还是不行啊
------ 怎么个不行法？

starwing83

回复 3# 幻の上帝


    我觉得你说反了。重载解析是在编译期做的，所以实际上参与重载解析的只有Base里面的函数。

如果了解了C++对象模型这个问题就很直接了。你要认为函数签名也是函数名的一部分，其次虚函数表是一个函数签名->函数指针的哈希表，那么函数签名不一样，自然在这个虚函数表里面的位置也不一样，最终自然取不到对应的东西，这个哈希的过程是编译期做的，而哈希完了以后，取各个类对应的项才是运行时的内容，所以虚函数的签名一定是完全一致的，否则运行期根本就调用不到。lz写的这个例子恰好有两个f签名一致~

zuiwei

bruceteen 发表于 2012-05-03 09:21
我写在child类里面发现还是不行啊
------ 怎么个不行法？

还是输出child.f

这个using base::f写在哪里才会发挥作用呢?

bruceteen

zuiwei 发表于 2012-05-03 09:26
还是输出child.f

难道不应该是 child.f 吗？
除非你改 pb->f(1.0f); 为 pb->f(1);