对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=1;
        Apirvate();
        AprotectedVar=1;
        Aprotected();
        ApublicVar=1;
        Apublic();
    }
};

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

        AprotectedVar=1;
        Aprotected();

        ApublicVar=1;
        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=1;
        Aprotected();

        ApublicVar=1;
        Apublic();
    }
};


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

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

        ApublicVar=1;//子类可以访问基类中的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 0;
}

/*
总结一下:
        基类的实例对象,在这里和普通类是一样的,只能访问类的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继承时,基类的成员也只能由直接派生类访问,不能在往下继承.

*/