一、 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 <iostream>
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 <iostream>
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 <iostream>
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 <iostream>
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 <iostream>
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 <iostream>
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);
}
其中子類Derived中 vitual void f(float x) 是覆蓋，而void g(int x) 和void h(float x)都是隱藏。
運行結果：
再看一個例子：
[html]
#include <iostream>
using namespace std;
class Base
{
public:
virtual void f(int a) {
cout << "virtual Base::f(int a)" << endl;
}
void f(double d) {
cout << "Base::f(double d)" << endl;
}
};
class Derived : public Base
{
public:
void f(double d) {
cout << "Derivd::f(double d)" << endl;
}
};
int main()
{
Derived d;
d.f(3);
d.f(2.5);
Derived *pd = new Derived();
pd->f(3);
pd->f(2.5);
Base b;
b.f(5);
b.f(3.5);
Base *pBase = new Derived();
pBase->f(5);
pBase->f(3.5);
}
#include <iostream>
using namespace std;
class Base
{
public:
virtual void f(int a) {
cout << "virtual Base::f(int a)" << endl;
}
void f(double d) {
cout << "Base::f(double d)" << endl;
}
};
class Derived : public Base
{
public:
void f(double d) {
cout << "Derivd::f(double d)" << endl;
}
};
int main()
{
Derived d;
d.f(3);
d.f(2.5);
Derived *pd = new Derived();
pd->f(3);
pd->f(2.5);
Base b;
b.f(5);
b.f(3.5);
Base *pBase = new Derived();
pBase->f(5);
pBase->f(3.5);
}
其中父類中的void f(double d)隱藏了子類的virtual void f(int a), void f(double d)函數。
所以在主函數中
[html]
Derived d;
d.f(3);
d.f(2.5);
Derived *pd = new Derived();
pd->f(3);
pd->f(2.5);
Derived d;
d.f(3);
d.f(2.5);
Derived *pd = new Derived();
pd->f(3);
pd->f(2.5);只要通過Derived對象或者Derived指針執行f()函數，都只執行void Derived::f(double d)該函數。
[html]
Base *pBase = new Derived();
pBase->f(5);
pBase->f(3.5);
Base *pBase = new Derived();
pBase->f(5);
pBase->f(3.5);在調用pBase->f(5)時，首先要去pBase類中找到對應需要執行的函數，因為Base類中有兩個函數virtual void f(int a) 和 void f(double)重載，因為該實參是5，為int類型，所以要調用virtual void f(int a)函數，因為該f(int a)是一個虛函數，所以再去判斷pBase所指向的具體對象，具體對象為Derived子類，再去Derived子類的虛函數表中找到void f(int a)函數。因為Derived子類繼承了父類Base的虛函數vitural void f(int a)，所以輸出 virtual Base::f(int a);
在調用pBase->f(3.5)時，首先要去pBase類中找到對應需要執行的函數，因為因為Base類中有兩個函數virtual void f(int a) 和 void f(double)重載，因為該實參是3.5，為double類，所以要調用void f(double d)函數，因為該函數是一個普通成員函數，故直接輸出。 void Base::f(double d);
再舉一個例子：
[html]
#include <iostream>
using namespace std;
class Base
{
public:
virtual void f(int a) {
cout << "virtual Base::f(int a)" << endl;
}
void f(double d) {
cout << "Base::f(double d)" << endl;
}
};
class Derived : public Base
{
public:
void f(int a) {
cout << "virtual Derived::f(int a)" << endl;
}
};
int main()
{
Derived d;
d.f(3);
d.f(2.5);
Derived *pd = new Derived();
pd->f(3);
pd->f(2.5);
Base b;
b.f(5);
b.f(3.5);
Base *pBase = new Derived();
pBase->f(5);
pBase->f(3.5);
}
#include <iostream>
using namespace std;
class Base
{
public:
virtual void f(int a) {
cout << "virtual Base::f(int a)" << endl;
}
void f(double d) {
cout << "Base::f(double d)" << endl;
}
};
class Derived : public Base
{
public:
void f(int a) {
cout << "virtual Derived::f(int a)" << endl;
}
};
int main()
{
Derived d;
d.f(3);
d.f(2.5);
Derived *pd = new Derived();
pd->f(3);
pd->f(2.5);
Base b;
b.f(5);
b.f(3.5);
Base *pBase = new Derived();
pBase->f(5);
pBase->f(3.5);
}
子類Derived中的void f(int a)既覆蓋了基類Base的虛函數virtual void f(int a)，也隱藏了基類的virtual void f(int a), void f(double d)函數。
[html]
Derived d;
d.f(3);
d.f(2.5);
Derived *pd = new Derived();
pd->f(3);
pd->f(2.5);
Derived d;
d.f(3);
d.f(2.5);
Derived *pd = new Derived();
pd->f(3);
pd->f(2.5);同理所有用子類對象或者子類指針來調用f()函數時，都只執行virtual void f(int a)，輸出virtual Derived::f(int a)
[html] view plaincopyprint?Base *pBase = new Derived();
pBase->f(5);
pBase->f(3.5);
Base *pBase = new Derived();
pBase->f(5);
pBase->f(3.5);pBase->f(5)，首先去Base類中尋找相應的函數，同理Base類中的兩個函數virtual void f(int a)和void f(double d)是重載函數，因為實參為5,為int類型，所以我們要調用virtual void f(int a)虛函數，因為該函數是虛函數，所以要去判斷pBase指向的具體對象，因為pBase指向的是一個子類的對象，所以需要去子類的虛函數表中取找virtual void f(int a)函數，找到之後，執行該函數，故輸出virtual Derived::f(int a)。
pBase->f(3.5),首先去Base類中尋找相應的函數，同理Base類中的兩個函數virtual void f(int a)和void f(double d)是重載函數，因為實參為3.5,為double類型，所以我們要調用void f(double d)，因為該函數為普通成員函數，故執行輸出： void Base::f(double d);
