一、 C++成员函数的重载
C++中的成员函数有四种，分别是普通成员函数，virtual虚函数，const成员函数。
(1) void func(int a);
(2) virtual void func(int a);
(3) void func(int a) const;
如果在一个类中，声明这四种函数，哪是重复定义？哪些是重载？
其中(1)(2)是重复定义，故编译不能通过，而(3)与(1)(2)是不同类型的函数，是重载。
成员函数被重载的特征是：
(1)具有相同的作用域(即同一个类定义中)；
(2)函数名字相同
(3)参数类型，顺序 或 数目不同(包括const参数和非const函数)
(4)virtual关键字可有可无。
从成员函数的重载特征中，可以知道(1)(2)是重复定义。那么(3)为什么和(1)(2)不同呢？
因为类中的函数，都会自动添加一个自身类指针this，所以
void func(int a) ==== void func(Base * this, int a)
virtual func(int a) ==== virtual func(Base *this, int a)
void func(int a)const === void func(const Base *this, int a) const
所以(3)可以与(1)(2)发生重载，因为参数有一个const。
二 、C++成员函数的继承
[html]
#include
using namespace std;
class Base {
public:
void f(int a){
cout << "Base::f(int a)" << endl;
}
virtual void g(int a) {
cout << "virtual Base::g(int a)" << endl;
}
};
class Derived : public Base
{
public:
void h(int a) {
cout << "Derivd::h(int a)" << endl;
}
};
int main()
{
Base b;
b.f(3);
b.g(4);
Derived d;
d.f(3);
d.g(4);
d.h(3);
}
#include
using namespace std;
class Base {
public:
void f(int a){
cout << "Base::f(int a)" << endl;
}
virtual void g(int a) {
cout << "virtual Base::g(int a)" << endl;
}
};
class Derived : public Base
{
public:
void h(int a) {
cout << "Derivd::h(int a)" << endl;
}
};
int main()
{
Base b;
b.f(3);
b.g(4);
Derived d;
d.f(3);
d.g(4);
d.h(3);
}
Base b的对象模型：
Derived d的对象模型：
则在子类Derived d中继承了父类中的virtual void g(int a) ; void f(int a);
运行结果为：
三、C++成员函数的覆盖
覆盖是指派生类重新实现(或者改写)了基类的成员函数，其特征是：
(1)不同的作用域(非别位于派生类和基类中)；
(2)函数名称相同
(3)参数列表完全相同；
(4)基类函数必须是虚函数。
从(4)中我们得知覆盖只是针对虚函数的。
[html]
#include
using namespace std;
class Base {
public:
void f(int a){
cout << "Base::f(int a)" << endl;
}
virtual void g(int a) {
cout << "virtual Base::g(int a)" << endl;
}
};
class Derived : public Base
{
public:
void h(int a) {
cout << "Derivd::h(int a)" << endl;
}
virtual void g(int a) {
cout << "virtual Derived::g(int a)" << endl;
}
};
int main()
{
Base b;
b.f(3);
b.g(4);
Derived d;
d.f(3);
d.g(4);
d.h(3);
}
#include
using namespace std;
class Base {
public:
void f(int a){
cout << "Base::f(int a)" << endl;
}
virtual void g(int a) {
cout << "virtual Base::g(int a)" << endl;
}
};
class Derived : public Base
{
public:
void h(int a) {
cout << "Derivd::h(int a)" << endl;
}
virtual void g(int a) {
cout << "virtual Derived::g(int a)" << endl;
}
};
int main()
{
Base b;
b.f(3);
b.g(4);
Derived d;
d.f(3);
d.g(4);
d.h(3);
}
Derived d对象模型如下：
其中Derived中重新定义了基类的虚成员函数virtual void g(int a)；
四、C++成员函数的隐藏
隐藏是指派生类的成员函数遮蔽了与其同名的基类成员函数，具体规则如下：
(1) 派生类的函数与基类的函数同名，但是参数列表有所差异。此时，不论有无virtual关键字，基类的函数在派生类中将被隐藏。(注意别与重载混合)
(2)派生类的函数与基类的函数同名，参数列表也相同，但是基类函数没有virtual关键字。此时，基类的函数在派生类中将被吟唱。(注意别与覆盖混合)
判断下面哪些函数是覆盖，哪些函数是隐藏？
[html]
#include
using namespace std;
class Base {
public:
virtual void f(float x) {
cout << "virtual Base::f(float) " << x << endl;
}
void g(float x) {
cout << "Base::g(float) " << x << endl;
}
void h(float x) {
cout << "Base::h(float) " << x << endl;
}
};
class Derived : public Base{
public:
virtual void f(float x) {
cout << "virtual Derived::f(float) " << x << endl;
}
void g(int x) {
cout << "Derived::g(int) " << x << endl;
}
void h(float x) {
cout << "Derived::h(float) " << x << endl;
}
};
int main(void)
{
Derived d;
Base *pb = &d;
Derived *pd = &d;
pb->f(3.14f);
pd->f(3.14f);
pb->g(3.14f);
pd->g(3.14f);
pb->h(3.14f);
pd->h(3.14f);
}
#include
using namespace std;
class Base {
public:
virtual void f(float x) {
cout << "virtual Base::f(float) " << x << endl;
}
void g(float x) {
cout << "Base::g(float) " << x << endl;
}
void h(float x) {
cout << "Base::h(float) " << x << endl;
}
};
class Derived : public Base{
public:
virtual void f(float x) {
cout << "virtual Derived::f(float) " << x << endl;
}
void g(int x) {
cout << "Derived::g(int) " << x << endl;
}
void h(float x) {
cout << "Derived::h(float) " << x << endl;
}
};
int main(void)
{
Derived d;
Base *pb = &d;
Derived *pd = &d;
pb->f(3.14f);
pd->f(3.14f);
pb->g(3.14f);
pd->g(3.14f);