| « | July 2026 | » | | 日 | 一 | 二 | 三 | 四 | 五 | 六 | | | | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | | |
|
公告 |
| 暂无公告... |
| Blog信息 |
|
blog名称:
日志总数:32
评论数量:44
留言数量:0
访问次数:182539
建立时间:2005年1月4日 |
| |
|
 重载、覆盖、多态与函数隐藏[1,2]
文章收藏
eaglebetter 发表于 2006/10/25 20:10:16 |
| 首先，我们来看一个非常简单的例子，理解一下什么叫函数隐藏hide。
#include <iostream>
using namespace std;
class Base{
public:
void fun() { cout << "Base::fun()" << endl; }
};
class Derive : public Base{
public:
void fun(int i) { cout << "Derive::fun()" << endl; }
};
int main()
{
Derive d;
//下面一句错误，故屏蔽掉
//d.fun();error C2660: 'fun' : function does not take 0 parameters
d.fun(1);
Derive *pd =new Derive();
//下面一句错误，故屏蔽掉
//pd->fun();error C2660: 'fun' : function does not take 0 parameters
pd->fun(1);
delete pd;
return 0;
}
/*在不同的非命名空间作用域里的函数不构成重载,子类和父类是不同的两个作用域。
在本例中,两个函数在不同作用域中,故不够成重载,除非这个作用域是命名空间作用域。*/
在这个例子中，函数不是重载overload，也不是覆盖override，而是隐藏hide。
接下来的5个例子具体说明一下什么叫隐藏
例1
#include <iostream>
using namespace std;
class Basic{
public:
void fun(){cout << "Base::fun()" << endl;}//overload
void fun(int i){cout << "Base::fun(int i)" << endl;}//overload
};
class Derive :public Basic{
public:
void fun2(){cout << "Derive::fun2()" << endl;}
};
int main()
{
Derive d;
d.fun();//正确，派生类没有与基类同名函数声明，则基类中的所有同名重载函数都会作为候选函数。
d.fun(1);//正确，派生类没有与基类同名函数声明，则基类中的所有同名重载函数都会作为候选函数。
return 0;
}
例2
#include <iostream>
using namespace std;
class Basic{
public:
void fun(){cout << "Base::fun()" << endl;}//overload
void fun(int i){cout << "Base::fun(int i)" << endl;}//overload
};
class Derive :public Basic{
public:
//新的函数版本,基类所有的重载版本都被屏蔽,在这里,我们称之为函数隐藏hide
//派生类中有基类的同名函数的声明，则基类中的同名函数不会作为候选函数，即使基类有不同的参数表的多个版本的重载函数。
void fun(int i,int j){cout << "Derive::fun(int i,int j)" << endl;}
void fun2(){cout << "Derive::fun2()" << endl;}
};
int main()
{
Derive d;
d.fun(1,2);
//下面一句错误，故屏蔽掉
//d.fun();error C2660: 'fun' : function does not take 0 parameters
return 0;
}
例3
#include <iostream>
using namespace std;
class Basic{
public:
void fun(){cout << "Base::fun()" << endl;}//overload
void fun(int i){cout << "Base::fun(int i)" << endl;}//overload
};
class Derive :public Basic{
public:
//覆盖override基类的其中一个函数版本,同样基类所有的重载版本都被隐藏hide
//派生类中有基类的同名函数的声明，则基类中的同名函数不会作为候选函数，即使基类有不同的参数表的多个版本的重载函数。
void fun(){cout << "Derive::fun()" << endl;}
void fun2(){cout << "Derive::fun2()" << endl;}
};
int main()
{
Derive d;
d.fun();
//下面一句错误，故屏蔽掉
//d.fun(1);error C2660: 'fun' : function does not take 1 parameters
return 0;
}
例4
#include <iostream>
using namespace std;
class Basic{
public:
void fun(){cout << "Base::fun()" << endl;}//overload
void fun(int i){cout << "Base::fun(int i)" << endl;}//overload
};
class Derive :public Basic{
public:
using Basic::fun;
void fun(){cout << "Derive::fun()" << endl;}
void fun2(){cout << "Derive::fun2()" << endl;}
};
int main()
{
Derive d;
d.fun();//正确
d.fun(1);//正确
return 0;
}
/*
输出结果
Derive::fun()
Base::fun(int i)
Press any key to continue
*/
例5
#include <iostream>
using namespace std;
class Basic{
public:
void fun(){cout << "Base::fun()" << endl;}//overload
void fun(int i){cout << "Base::fun(int i)" << endl;}//overload
};
class Derive :public Basic{
public:
using Basic::fun;
void fun(int i,int j){cout << "Derive::fun(int i,int j)" << endl;}
void fun2(){cout << "Derive::fun2()" << endl;}
};
int main()
{
Derive d;
d.fun();//正确
d.fun(1);//正确
d.fun(1,2);//正确
return 0;
}
/*
输出结果
Base::fun()
Base::fun(int i)
Derive::fun(int i,int j)
Press any key to continue
*/
好了，我们先来一个小小的总结重载与覆盖两者之间的特征
重载overload的特征：
n 相同的范围(在同一个类中)；
n 函数名相同参数不同；
n virtual 关键字可有可无。
覆盖override是指派生类函数覆盖基类函数，覆盖的特征是：
n 不同的范围(分别位于派生类与基类)；
n 函数名和参数都相同；
n 基类函数必须有virtual 关键字。(若没有virtual 关键字则称之为隐藏hide)
如果基类有某个函数的多个重载(overload)版本，而你在派生类中重写(override)了基类中的一个或多个函数版本，或是在派生类中重新添加了新的函数版本(函数名相同，参数不同)，则所有基类的重载版本都被屏蔽，在这里我们称之为隐藏hide。所以，在一般情况下，你想在派生类中使用新的函数版本又想使用基类的函数版本时，你应该在派生类中重写基类中的所有重载版本。你若是不想重写基类的重载的函数版本，则你应该使用例4或例5方式，显式声明基类名字空间作用域。
事实上，C++编译器认为，相同函数名不同参数的函数之间根本没有什么关系，它们根本就是两个毫不相关的函数。只是C++语
言为了模拟现实世界，为了让程序员更直观的思维处理现实世界中的问题，才引入了重载和覆盖的概念。重载是在相同名字空间作用域下，而覆盖则是在不同的名字
空间作用域下，比如基类和派生类即为两个不同的名字空间作用域。在继承过程中，若发生派生类与基类函数同名问题时，便会发生基类函数的隐藏。当然，这里讨
论的情况是基类函数前面没有virtual 关键字。在有virtual 关键字关键字时的情形我们另做讨论。
继承类重写了基类的某一函数版本，以产生自己功能的接口。此时C++编绎器认为，你现在既然要使用派生类的自己重新改写的接口，那我基类的接口就不提供给你了(当然你可以用显式声明名字空间作用域的方法，见[C++基础]重载、覆盖、多态与函数隐藏(1))。而不会理会你基类的接口是有重载特性的。若是你要在派生类里继续保持重载的特性，那你就自己再给出接口重载的特性吧。所以在派生类里，只要函数名一样，基类的函数版本就会被无情地屏蔽。在编绎器中，屏蔽是通过名字空间作用域实现的。
所以，在派生类中要保持基类的函数重载版本，就应该重写所有基类的重载版本。重载只在当前类中有效，继承会失去函数重载的特性。也就是说，要把基类的重载函数放在继承的派生类里，就必须重写。
这里“隐藏”是指派生类的函数屏蔽了与其同名的基类函数，具体规则我们也来做一小结：
n 如果派生类的函数与基类的函数同名，但是参数不同。此时，若基类无virtual关键字，基类的函数将被隐藏。(注意别与重载混淆，虽然函数名相同参数不同应称之为重载，但这里不能理解为重载，因为派生类和基类不在同一名字空间作用域内。这里理解为隐藏)
n 如果派生类的函数与基类的函数同名，但是参数不同。此时，若基类有virtual关键字，基类的函数将被隐式继承到派生类的vtable中。此时派生类vtable中的函数指向基类版本的函数地址。同时这个新的函数版本添加到派生类中，作为派生类的重载版本。但在基类指针实现多态调用函数方法时，这个新的派生类函数版本将会被隐藏。
n 如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual关键字。此时，基类的函数被隐藏。(注意别与覆盖混淆，这里理解为隐藏)。
n 如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数有virtual关键字。此时，基类的函数不会被“隐藏”。(在这里，你要理解为覆盖哦^_^)。
插曲：基类函数前没有virtual关键字时，我们要重写更为顺口些，在有virtual关键字时，我们叫覆盖更为合理些，戒此，我也希望大家能够更好的理解C++中一些微妙的东西。费话少说，我们举例说明吧。
例6
#include <iostream>
using namespace std;
class Base{
public:
virtual void fun() { cout << "Base::fun()" << endl; }//overload
virtual void fun(int i) { cout << "Base::fun(int i)" << endl; }//overload
};
class Derive : public Base{
public:
void fun() { cout << "Derive::fun()" << endl; }//override
void fun(int i) { cout << "Derive::fun(int i)" << endl; }//override
void fun(int i,int j){ cout<< "Derive::fun(int i,int j)" <<endl;}//overload
};
int main()
{
Base *pb = new Derive();
pb->fun();
pb->fun(1);
//下面一句错误，故屏蔽掉
//pb->fun(1,2);virtual函数不能进行overload,error C2661: 'fun' : no overloaded function takes 2 parameters
cout << endl;
Derive *pd = new Derive();
pd->fun();
pd->fun(1);
pd->fun(1,2);//overload
delete pb;
delete pd;
return 0;
}
/*
输出结果
Derive::fun()
Derive::fun(int i)
Derive::fun()
Derive::fun(int i)
Derive::fun(int i,int j)
Press any key to continue
*/
例7-1
#include <iostream>
using namespace std;
class Base{
public:
virtual void fun(int i){ cout <<"Base::fun(int i)"<< endl; }
};
class Derive : public Base{};
int main()
{
Base *pb = new Derive();
pb->fun(1);//Base::fun(int i)
delete pb;
return 0;
}
例7-2
#include <iostream>
using namespace std;
class Base{
public:
virtual void fun(int i){ cout <<"Base::fun(int i)"<< endl; }
};
class Derive : public Base{
public:
void fun(double d){ cout <<"Derive::fun(double d)"<< endl; }
};
int main()
{
Base *pb = new Derive();
pb->fun(1);//Base::fun(int i)
pb->fun((double)0.01);//Base::fun(int i)
delete pb;
return 0;
}
例8-1
#include <iostream>
using namespace std;
class Base{
public:
virtual void fun(int i){ cout <<"Base::fun(int i)"<< endl; }
};
class Derive : public Base{
public:
void fun(int i){ cout <<"Derive::fun(int i)"<< endl; }
};
int main()
{
Base *pb = new Derive();
pb->fun(1);//Derive::fun(int i)
delete pb;
return 0;
}
|
|
|