对private protected public的详解:

 #include <iostream>
 #include <stack>
 #include <queue>
 #include <exception>
 #include <sstream>
 #include <string>
 #include <vector>
 #include<list>
 #include<cassert>
 #include<cstdlib>
 using namespace std;

 class A{
 private:
     int AprivateVar;
     void Apirvate()
     {
         cout<<"A:Aprivate()"<<endl;
     }
 protected:
     int AprotectedVar;
     void Aprotected()
     {
         cout<<"A:Aprotected()"<<endl;
     }
 public:
     int ApublicVar;
     void Apublic()
     {
         cout<<"A:Apublic()"<<endl;
     }

     void Test()
     {
         AprivateVar=;
         Apirvate();
         AprotectedVar=;
         Aprotected();
         ApublicVar=;
         Apublic();
     }
 };

 class Bprivate:private A
 {
 public:
     void test()
     {
         //访问基类private成员
         //    AprivateVar=1;//这里因为子类声明的是private故不可访问
         //    Apirvate();//这里因为子类声明的是private故不可访问

         AprotectedVar=;
         Aprotected();

         ApublicVar=;
         Apublic();
     }
 };

 class Cprivate:public Bprivate
 {
 public:
     void test()
     {
         //此处全都不能访问
         //在子类中:基类的public成员和protected成员是可见的.基类的public成员和protected成员都变成子类的private成员,并且不能这个子类的派生类所访问.
         /*AprivateVar=1;/
         Apirvate();/

         AprotectedVar=1;
         Aprotected();

         ApublicVar=1;
         Apublic();*/
     }
 };

 class Bprotected:protected A
 {
 public:
     void test()
     {
         //访问基类private成员
         //AprivateVar=1;//这里因为子类声明的是private故不可访问
         //Apirvate();//这里因为子类声明的是private故不可访问

         AprotectedVar=;
         Aprotected();

         ApublicVar=;
         Apublic();
     }
 };

 class Bpublic:public A
 {
 public:
     void test()
     {
         //AprivateVar=1;//子类不能访问基类中的private成员
         //Apirvate();//子类不能访问基类中的private成员

         AprotectedVar=;//子类可以访问基类中的protected成员
         Aprotected();//子类可以访问基类中的protected成员

         ApublicVar=;//子类可以访问基类中的public成员
         Apublic();//子类可以访问基类中的public成员
     }
 };

 int main(int argc,char* argv[])
 {
     A testA;
     //    testA.Apirvate();//实例的私有方法不能访问
     //    testA.Aprotected();//实例的受保护方法不能访问
     testA.Apublic();

     Bprivate testB;
     //testB.Apirvate();//实例的私有方法不能访问
     //    testB.Aprotected();//实例的受保护方法不能访问
     //testB.Apublic();//因为是private继承的.所以.实例对象不能访问私有方法

     Bprotected testB2;
     //testB2.Apirvate();//实例的私有方法不能访问
     //testB2.Aprotected();//实例的受保护方法不能访问
     //testB2.Apublic();//实例的受保护方法不能访问

     Bpublic testB3;
     //testB3.Apirvate();//子类的实例对象.只能访问基类的public成员.
     //testB3.Aprotected();//子类的实例对象.只能访问基类的public成员.
     testB3.Apublic();//子类的实例对象.只能访问基类的public成员.
     return ;
 }

 /*
 总结一下:
         基类的实例对象,在这里和普通类是一样的,只能访问类的public成员方法和public成员变量;也就是public成员可见,protected和private是不可见的;
     1.Public继承:基类的public成员和protected成员对子类是可见的.继承以后public和protected都保持原有的状态.private是不可见的.也就是说子类
         中不能访问基类中的private成员,
         子类的实例对象.只能访问基类的public成员.以及自身的public成员.
         所以:在public继承时,子类的实例对象可以访问基类中的public成员.而子类中的成员方法可以访问基类中的public和protected成员.
     2.Private继承:基类的实例对象，可以访问基类的public成员(和普通类一样).
        在子类中:基类的public成员和protected成员是可见的.基类的public成员和protected成员都变成子类的private成员,这些public和protected成员不能被这个子类的派生类所访问.
        基类的私有成员是不可见的,也就是说子类不能访问基类中的私有成员.
        子类的实例对象,不能访问基类的所有成员.私有继承时,基类的成员只能由直接派生类访问,而无法再往下继承.
     3.protected继承:子类中可以访问基类的public成员和protected成员,基类的public和protected成员都变成protected成员,并且不能被这个派生类的子类所访问,基类的私有成员
        是不可见的,派生类不能访问基类中的私有成员.在protected继承时,基类的成员也只能由直接派生类访问,不能在往下继承.

 */