1 #include <iostream>
2 #include <stack>
3 #include <queue>
4 #include <exception>
5 #include <sstream>
6 #include <string>
7 #include <vector>
8 #include<list>
9 #include<cassert>
10 #include<cstdlib>
11 using namespace std;
12
13
14 class A{
15 private:
16 int AprivateVar;
17 void Apirvate()
18 {
19 cout<<"A:Aprivate()"<<endl;
20 }
21 protected:
22 int AprotectedVar;
23 void Aprotected()
24 {
25 cout<<"A:Aprotected()"<<endl;
26 }
27 public:
28 int ApublicVar;
29 void Apublic()
30 {
31 cout<<"A:Apublic()"<<endl;
32 }
33
34 void Test()
35 {
36 AprivateVar=1;
37 Apirvate();
38 AprotectedVar=1;
39 Aprotected();
40 ApublicVar=1;
41 Apublic();
42 }
43 };
44
45 class Bprivate:private A
46 {
47 public:
48 void test()
49 {
50 //访问基类private成员
51 // AprivateVar=1;//这里因为子类声明的是private故不可访问
52 // Apirvate();//这里因为子类声明的是private故不可访问
53
54 AprotectedVar=1;
55 Aprotected();
56
57 ApublicVar=1;
58 Apublic();
59 }
60 };
61
62 class Cprivate:public Bprivate
63 {
64 public:
65 void test()
66 {
67 //此处全都不能访问
68 //在子类中:基类的public成员和protected成员是可见的.基类的public成员和protected成员都变成子类的private成员,并且不能这个子类的派生类所访问.
69 /*AprivateVar=1;/
70 Apirvate();/
71
72 AprotectedVar=1;
73 Aprotected();
74
75 ApublicVar=1;
76 Apublic();*/
77 }
78 };
79
80 class Bprotected:protected A
81 {
82 public:
83 void test()
84 {
85 //访问基类private成员
86 //AprivateVar=1;//这里因为子类声明的是private故不可访问
87 //Apirvate();//这里因为子类声明的是private故不可访问
88
89 AprotectedVar=1;
90 Aprotected();
91
92 ApublicVar=1;
93 Apublic();
94 }
95 };
96
97
98 class Bpublic:public A
99 {
100 public:
101 void test()
102 {
103 //AprivateVar=1;//子类不能访问基类中的private成员
104 //Apirvate();//子类不能访问基类中的private成员
105
106 AprotectedVar=1;//子类可以访问基类中的protected成员
107 Aprotected();//子类可以访问基类中的protected成员
108
109 ApublicVar=1;//子类可以访问基类中的public成员
110 Apublic();//子类可以访问基类中的public成员
111 }
112 };
113
114 int main(int argc,char* argv[])
115 {
116 A testA;
117 // testA.Apirvate();//实例的私有方法不能访问
118 // testA.Aprotected();//实例的受保护方法不能访问
119 testA.Apublic();
120
121 Bprivate testB;
122 //testB.Apirvate();//实例的私有方法不能访问
123 // testB.Aprotected();//实例的受保护方法不能访问
124 //testB.Apublic();//因为是private继承的.所以.实例对象不能访问私有方法
125
126 Bprotected testB2;
127 //testB2.Apirvate();//实例的私有方法不能访问
128 //testB2.Aprotected();//实例的受保护方法不能访问
129 //testB2.Apublic();//实例的受保护方法不能访问
130
131 Bpublic testB3;
132 //testB3.Apirvate();//子类的实例对象.只能访问基类的public成员.
133 //testB3.Aprotected();//子类的实例对象.只能访问基类的public成员.
134 testB3.Apublic();//子类的实例对象.只能访问基类的public成员.
135 return 0;
136 }
137
138 /*
139 总结一下:
140 基类的实例对象,在这里和普通类是一样的,只能访问类的public成员方法和public成员变量;也就是public成员可见,protected和private是不可见的;
141 1.Public继承:基类的public成员和protected成员对子类是可见的.继承以后public和protected都保持原有的状态.private是不可见的.也就是说子类
142 中不能访问基类中的private成员,
143 子类的实例对象.只能访问基类的public成员.以及自身的public成员.
144 所以:在public继承时,子类的实例对象可以访问基类中的public成员.而子类中的成员方法可以访问基类中的public和protected成员.
145 2.Private继承:基类的实例对象，可以访问基类的public成员(和普通类一样).
146 在子类中:基类的public成员和protected成员是可见的.基类的public成员和protected成员都变成子类的private成员,这些public和protected成员不能被这个子类的派生类所访问.
147 基类的私有成员是不可见的,也就是说子类不能访问基类中的私有成员.
148 子类的实例对象,不能访问基类的所有成员.私有继承时,基类的成员只能由直接派生类访问,而无法再往下继承.
149 3.protected继承:子类中可以访问基类的public成员和protected成员,基类的public和protected成员都变成protected成员,并且不能被这个派生类的子类所访问,基类的私有成员
150 是不可见的,派生类不能访问基类中的私有成员.在protected继承时,基类的成员也只能由直接派生类访问,不能在往下继承.
151
152 */
