Chinaunix首页 | 论坛 | 博客
  • 博客访问: 3726394
  • 博文数量: 356
  • 博客积分: 10458
  • 博客等级: 上将
  • 技术积分: 4734
  • 用 户 组: 普通用户
  • 注册时间: 2008-03-24 14:59
文章分类

全部博文(356)

文章存档

2020年(17)

2019年(9)

2018年(26)

2017年(5)

2016年(11)

2015年(20)

2014年(2)

2013年(17)

2012年(15)

2011年(4)

2010年(7)

2009年(14)

2008年(209)

分类: C/C++

2008-05-17 18:53:21

引用:http://www.150it.cn/bianchengwendang/Cjia/7289120971.html
如果基类声明了一个成员函数f(int),并且派生类声明了一个成员函数f(float)(名称相同,但参数类型或数量不同),那么Base的f(int)被隐藏(hidden)而不是被重载(overloaded)或被重写(overridden)(即使基类的f(int)是虚的)    
 
以下是你如何摆脱困境:派生类必须有一个被隐藏成员函数的using声明,例如:    
 
class  Base{  
public:  
voidf(int);  
};  
 
classDerived:publicBase{  
public:  
usingBase::f;//Thisun-hidesBase::f(int)  
voidf(double);  
};    
 
如果你的编译器不支持using语法,那么就重新定义基类的被隐藏的成员函数,即使它们是非虚的。一般来说这种重定义只不过使用::语法调用了基类被隐藏的成员函数,如,    
 
classDerived:publicBase{  
public:  
voidf(double);  
voidf(inti){Base::f(i);}//TheredefinitionmerelycallsBase::f(int)  
};    
 
 
以下是俺的程序:  
 
class  Parent  
{  
public:  
           virtual  void  foo()  
           {  
                       cout  <<  "foo  from  Parent"  <<  endl;;      
           }  
           void  foo1()  
           {  
                       cout  <<  "foo1  from  Parent"  <<  endl;;  
           }  
           virtual  void  foo2()  
           {  
                       cout  <<  "foo2  from  Parent"  <<  endl;;  
           }  
};  
 
class  Son  :  public  Parent  
{  
public:  
           void  foo()  
           {  
                       cout  <<  "foo  from  Son"  <<  endl;;      
           }  
           void  foo1()  
           {  
                       cout  <<  "foo1  from  Son"  <<  endl;;  
           }  
           void  foo2(int  i)  
           {  
                       cout  <<  "foo2  from  Son"  <<  endl;;  
           }  
};  
 
int  _tmain(int  argc,  _TCHAR*  argv[])  
{  
           Parent  *p  =  new  Son();  
           p->foo();  
           p->foo1();  
           p->foo2();  
 
           delete  p;  
           system("pause");  
           return  0;  
}  
 
如果按照"隐藏"的说法,foo2()被隐藏的话,那么应该编译不过才对。然而VC的输出是  
 
foo  from  Son  
foo1  from  Parent  
foo2  from  Parent  
 
那么,隐藏的机制到底是不是标准C++?我的做法可以被看作overload吗?  
隐藏是否只在foo1()中生效。即,隐藏也要看参数和类型完全一致,且父类的不能是虚函数?  
 
 ---------------------------------------------------------------  
 
int  main()  
{  
           Parent  *p  =  new  Son();  
           p->foo();                  //覆盖  一、(1)  
           p->foo1();                //隐藏  二、(2)  
           p->foo2();                //隐藏  二、(1)  
           delete  p;  
//            system("pause");  
           return  0;  
}  
一、覆盖是指派生类函数覆盖基类函数,特征是:  
(1)不同的范围(分别位于派生类与基类);  
(2)函数名字相同;  
(3)参数相同;  
(4)基类函数必须有virtual关键字。  
二、"隐藏"是指派生类的函数屏蔽了与其同名的基类函数,规则如下:  
(1)如果派生类的函数与基类的函数同名,但是参数不同。此时,不论有无virtual关键字,基类的函数将被隐藏(注意别与重载混淆)。  
(2)如果派生类的函数与基类的函数同名,并且参数也相同,但是基类函数没有virtual关键字。此时,基类的函数被隐藏(注意别与覆盖混淆)。  
---------------------------------------------------------------  
 
其实这样来理解就比较容易搞懂了:  
1.虚函数的使用有特殊性,在使用的时候会查询指针所指对象内的虚函数表来确定具体应该调用的函数地址。因此调用虚函数的时候优先使用指针所指对象的类函数,而不是其基类的类函数,如果找不到则才从其基类中找一个匹配的成员函数  
比如:  
p->foo();//因为p指向的是派生类Son的对象,因此优先使用Son的成员函数foo()  
p->foo2();//Son类从不存在foo2(),但是从其基类中可以找到。因为没有重载,虚函数表中保存的是基类的成员函数foo2的指针。  
2.非虚成员函数的调用则是直接调用指针所指类对象的成员函数,而不会动态编译。  
比如:  
p->foo1();//编译器直接找到Parent类型的成员函数进行静态编译。  
 
---------------------------------------------------------------  
 
隐藏的几个特征:  
1 在基类和派生类之间  
2 函数名字相同  
 如果参数类型不同的时候,有无virtual 关键字都为隐藏  
 如果参数类型相同,则,无virtual 关键字时为隐藏  
顺便说说函数的重载与覆盖:  
重载:  
1 在同一个类里面  
2 函数名字相同  
3 函数参数不同  
4 virtual 关键字有无均可  
 
覆盖:  
1 在基类和派生类之间  
2 函数名字相同  
3 参数类型相同  
4 有virtual关键字  
 
上面是从 高质量C++编程指南看到的.  
---------------------------------------------------------------  
 
覆盖  主要用于从基类访问派生类  
而  隐藏  不行,只是隐藏掉了基类的函数,基类变量访问的只能是基类的那个函数  
重载  只是在同一个类里面  
 
---------------------------------------------------------------  
自己试了n多次,才基本明白这个意思...重载(overload)只在同一个类里生效。  
 
foo()是经典的override,而foo1()和foo2()全是hide,也即,foo1()和foo2()在子类中不可见。这里要注意,大家通常不会把foo1()认错,而对foo2()也是hide的行为通常不敏感。  
 
只要子类中有一个同名的方法,不管他的参数列表是不是对得上,也不管父类的方法是不是virtual的(实际上,在这个case中不考虑virtual反而不容易胡涂...记得只要没有override,虚表调用和非虚调用的结果并无区别。这一点jixingzhong兄要注意了),在子类中就不可能再看到父类中的所有同名方法。  
 
然而,为什么我的返回不出错呢?因为我用的是..  父  类  的  指  针。  
foo()调用->典型的多态,动态连接到子类的虚表foo
阅读(3781) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~