初學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，在類外可以訪問。
感興趣的讀者可以調試運行一下本文實例，加深印象的同時還會有新的收獲。