深刻理解C++中public、protected及private用法

初學C++的朋友常常在類中看到public，protected，private以及它們在繼承中表示的一些訪問範圍，很容易搞糊塗。今天本文就來十分分析一下C++中public、protected及private用法。相信對於你們深刻掌握C++程序設計會有很大的幫助。

這裏咱們首先要明白下面幾點。

1.類的一個特徵就是封裝，public和private做用就是實現這一目的。因此：

用戶代碼（類外）能夠訪問public成員而不能訪問private成員；private成員只能由類成員（類內）和友元訪問。

2.類的另外一個特徵就是繼承，protected的做用就是實現這一目的。因此：

protected成員能夠被派生類對象訪問，不能被用戶代碼（類外）訪問。

現來看看以下示例：

?

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 32 33 34

#include<iostream> #include<assert.h> using namespace std; class A{ public :    int a;    A(){      a1 = 1;      a2 = 2;      a3 = 3;      a = 4;    }    void fun(){      cout << a << endl;    //正確      cout << a1 << endl;   //正確      cout << a2 << endl;   //正確，類內訪問      cout << a3 << endl;   //正確，類內訪問    } public :    int a1; protected :    int a2; private :    int a3; }; int main(){    A itema;    itema.a = 10;    //正確    itema.a1 = 20;    //正確    itema.a2 = 30;    //錯誤，類外不能訪問protected成員    itema.a3 = 40;    //錯誤，類外不能訪問private成員    system ( "pause" );    return 0; }

繼承中的特色：

先記住：無論是否繼承，上面的規則永遠適用！

有public, protected, private三種繼承方式，它們相應地改變了基類成員的訪問屬性。

1.public繼承：基類public成員，protected成員，private成員的訪問屬性在派生類中分別變成：public, protected, private

2.protected繼承：基類public成員，protected成員，private成員的訪問屬性在派生類中分別變成：protected, protected, private

3.private繼承：基類public成員，protected成員，private成員的訪問屬性在派生類中分別變成：private, private, private

但不管哪一種繼承方式，上面兩點都沒有改變：

1.private成員只能被本類成員（類內）和友元訪問，不能被派生類訪問；

2.protected成員能夠被派生類訪問。

再來看看如下代碼：

1.public繼承

代碼以下：

?

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 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

#include<iostream> #include<assert.h> using namespace std;   class A{ public :    int a;    A(){      a1 = 1;      a2 = 2;      a3 = 3;      a = 4;    }    void fun(){      cout << a << endl;    //正確      cout << a1 << endl;   //正確      cout << a2 << endl;   //正確      cout << a3 << endl;   //正確    } public :    int a1; protected :    int a2; private :    int a3; }; class B : public A{ public :    int a;    B( int i){      A();      a = i;    }    void fun(){      cout << a << endl;       //正確，public成員      cout << a1 << endl;       //正確，基類的public成員，在派生類中還是public成員。      cout << a2 << endl;       //正確，基類的protected成員，在派生類中還是protected能夠被派生類訪問。      cout << a3 << endl;       //錯誤，基類的private成員不能被派生類訪問。    } }; int main(){    B b(10);    cout << b.a << endl;    cout << b.a1 << endl;   //正確    cout << b.a2 << endl;   //錯誤，類外不能訪問protected成員    cout << b.a3 << endl;   //錯誤，類外不能訪問private成員    system ( "pause" );    return 0; }

2.protected繼承：

代碼以下：

?

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 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48

#include<iostream> #include<assert.h> using namespace std; class A{ public :    int a;    A(){      a1 = 1;      a2 = 2;      a3 = 3;      a = 4;    }    void fun(){      cout << a << endl;    //正確      cout << a1 << endl;   //正確      cout << a2 << endl;   //正確      cout << a3 << endl;   //正確    } public :    int a1; protected :    int a2; private :    int a3; }; class B : protected A{ public :    int a;    B( int i){      A();      a = i;    }    void fun(){      cout << a << endl;       //正確，public成員。      cout << a1 << endl;       //正確，基類的public成員，在派生類中變成了protected，能夠被派生類訪問。      cout << a2 << endl;       //正確，基類的protected成員，在派生類中仍是protected，能夠被派生類訪問。      cout << a3 << endl;       //錯誤，基類的private成員不能被派生類訪問。    } }; int main(){    B b(10);    cout << b.a << endl;       //正確。public成員    cout << b.a1 << endl;      //錯誤，protected成員不能在類外訪問。    cout << b.a2 << endl;      //錯誤，protected成員不能在類外訪問。    cout << b.a3 << endl;      //錯誤，private成員不能在類外訪問。    system ( "pause" );    return 0; }

3.private繼承：

代碼以下：

?

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 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48

#include<iostream> #include<assert.h> using namespace std; class A{ public :    int a;    A(){      a1 = 1;      a2 = 2;      a3 = 3;      a = 4;    }    void fun(){      cout << a << endl;    //正確      cout << a1 << endl;   //正確      cout << a2 << endl;   //正確      cout << a3 << endl;   //正確    } public :    int a1; protected :    int a2; private :    int a3; }; class B : private A{ public :    int a;    B( int i){      A();      a = i;    }    void fun(){      cout << a << endl;       //正確，public成員。      cout << a1 << endl;       //正確，基類public成員,在派生類中變成了private,能夠被派生類訪問。      cout << a2 << endl;       //正確，基類的protected成員，在派生類中變成了private,能夠被派生類訪問。      cout << a3 << endl;       //錯誤，基類的private成員不能被派生類訪問。    } }; int main(){    B b(10);    cout << b.a << endl;       //正確。public成員    cout << b.a1 << endl;      //錯誤，private成員不能在類外訪問。    cout << b.a2 << endl;      //錯誤, private成員不能在類外訪問。    cout << b.a3 << endl;      //錯誤，private成員不能在類外訪問。    system ( "pause" );    return 0; }

經過以上的代碼都備有較爲詳盡的註釋，讀者應該可以理解。仔細看代碼中派生類B中定義了和基類同名的成員a，此時基類的a仍然存在，能夠驗證。

?

1 2 3 4 5 6 7

int main(){    cout << sizeof (A) << endl;    cout << sizeof (B) << endl;      system ( "pause" );    return 0; }

輸出：

16

20

因此派生類包含了基類全部成員以及新增的成員，同名的成員被隱藏起來，調用的時候只會調用派生類中的成員。

若是要調用基類的同名成員，能夠用如下方法：

?

1 2 3 4 5 6 7 8 9

int main(){      B b(10);    cout << b.a << endl;    cout << b.A::a << endl;      system ( "pause" );    return 0; }

輸出：

10

4

記得這裏是在類外訪問，而a在基類中是public，因此繼承方式應該爲public，使得a在派生類中仍然爲public，在類外能夠訪問。

感興趣的讀者能夠調試運行一下本文實例，加深印象的同時還會有新的收穫。