对private protected public的详解: 

  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 */

 

posted @ 2014-08-10 09:20  CrazyCode.  阅读(477)  评论(0)    收藏  举报