C++派生访问控制说明符

访问说明符(public,protected,private)类型：
        类成员访问说明符
        继承访问说明符
 
继承访问说明符说明了派生类中基类部分成员的继承方式。
    （1）通过public继承：派生类中基类部分成员的访问说明符在基类中为public或protected的，在派生类中类型保持不变，private的成员不可访问。
   （2）通过protected继承：派生类中基类部分成员的访问说明符在基类中为public或protected的，在派生类中类型为protected，private的成员不可访问。
   （3）通过private继承：派生类中基类部分成员的访问说明符在基类中为public或protected的，在派生类中类型为private，private的成员不可访问。
         (不可访问是指不能直接通过子类访问，但可以通过父类的成员访问)

C++中的继承方式（public、private、protected）会影响子类的对外访问属性，判断某一句话，能否被访问：
1）看调用语句，这句话写在子类的内部、外部
2）看子类如何从父类继承（public、private、protected）
3）看父类中的访问级别（public、private、protected）

 

现在,假设将访问的用户分为2级：

1.类内访问（类的实现者）
2.类的用户（可以理解成通过类的对象来访问）（类的普通用户）
        注：类内访问主要是指类的成员函数
        对于1级用户来说，可以访问除不可访问外的所有(public,protected,private)成员。2级用户只能访问public的成员。

        (这里被访问的成员都是指类成员访问说明符修饰的类成员)

其实，还有第三种类的用户——派生类！

基类class Base：

class Base{
public:
	//Constructor
	Base():base_public_string("I'm base_public_string"),base_protected_string("I'm base_protected_string"),base_private_string("I'm base_private_string")
	{}
	Base(string pub, string pro, string pri) :base_public_string(pub), base_protected_string(pro), base_private_string(pri)
	{}

	string base_public_string;      //public string member

protected:
	string base_protected_string;   //protect string member
private:
	string base_private_string;     //private string member
};
//包括两个public的构造函数和3个string类型的成员(public,protected,private各一个)。

通过public继承的类：

class PubDerv:public Base{
public:
       PubDerv():Base(){}
       PubDerv(std::string pub,std::string pro,std::string pri):Base(pub,pro,pri){}
       void pub_printParentMem()
       {
              std::cout<<base_public_string<<std::endl;
              std::cout<<base_protected_string<<std::endl;
              //std::cout<<base_private_string<<std::endl;//父类的私有成员不管以什么方式被继承都是不可访问
       }
protected:
       void pro_printParentMem()
       {
              std::cout<<base_public_string<<std::endl;
              std::cout<<base_protected_string<<std::endl;
              //std::cout<<base_private_string<<std::endl;
       }
private:
       void pri_printParentMem()
       {
              std::cout<<base_public_string<<std::endl;
              std::cout<<base_protected_string<<std::endl;
              //std::cout<<base_private_string<<std::endl;
       }
};

通过protected继承的类：

class ProDerv:protected Base{
public:
       ProDerv():Base(){}
       ProDerv(std::string pub,std::string pro,std::string pri):Base(pub,pro,pri){}
       void pub_printParentMem()
       {
              std::cout<<base_public_string<<std::endl;
              std::cout<<base_protected_string<<std::endl;
              //std::cout<<base_private_string<<std::endl;
       }
protected:
       void pro_printParentMem()
       {
              std::cout<<base_public_string<<std::endl;
              std::cout<<base_protected_string<<std::endl;
              //std::cout<<base_private_string<<std::endl;
       }
private:
       void pri_printParentMem()
       {
              std::cout<<base_public_string<<std::endl;
              std::cout<<base_protected_string<<std::endl;
              //std::cout<<base_private_string<<std::endl;
       }
};

通过private继承的类：

class PriDerv:private Base{
public:
       PriDerv():Base(){}
       PriDerv(std::string pub,std::string pro,std::string pri):Base(pub,pro,pri){}
       void pub_printParentMem()
       {
              std::cout<<base_public_string<<std::endl;
              std::cout<<base_protected_string<<std::endl;
              //std::cout<<base_private_string<<std::endl;
       }
protected:
       void pro_printParentMem()
       {
              std::cout<<base_public_string<<std::endl;
              std::cout<<base_protected_string<<std::endl;
              //std::cout<<base_private_string<<std::endl;
       }
private:
       void pri_printParentMem()
       {
              std::cout<<base_public_string<<std::endl;
              std::cout<<base_protected_string<<std::endl;
              //std::cout<<base_private_string<<std::endl;
       }
};

       3个子类的3个打印函数都相同，都是访问父类的3个string成员变量。
 
第1级访问（类内访问）：
1.不可访问成员：
       父类的私有成员不管以什么方式被继承都是不可访问。可以看到访问base_private_string的代码被注释掉了。因为如果不注释掉，由于不可访问的成员不能由子类直接访问，所以编译时会报错，如下：
 
以PubDerv为例，3个打印函数访问父类私有变量base_private_string，编译时报错
 
2.public，protected，private成员：
        而父类的公有成员和保护成员由于继承方式不同，在子类中的访问说明符也不同（具体见前面的表格），但是不管是继承下来后属于哪类，对于第1级访问来说，这些成员都能被访问。 因此3个子类对父类的公有成员和保护成员都能访问(编译未出错已经说明问题)。

第2级访问（类的普通用户）:

main.cpp：

void main()
{
       PubDerv pubDerv;
       ProDerv proDerv;
       PriDerv priDerv;
 
       cout<<"pubDerv:"<<endl;
       cout<<pubDerv.base_public_string<<endl;
       cout<<pubDerv.base_protected_string<<endl;
       cout<<pubDerv.base_private_string<<endl;
      
       /*
       cout<<"proDerv:"<<endl;
       cout<<proDerv.base_public_string<<endl;
       cout<<proDerv.base_protected_string<<endl;
       cout<<proDerv.base_private_string<<endl;
       */
 
       /*
       cout<<"priDerv:"<<endl;
       cout<<priDerv.base_public_string<<endl;
       cout<<priDerv.base_protected_string<<endl;
       cout<<priDerv.base_private_string<<endl;
       */
 
       /*
       cout<<"pubDerv:"<<endl;
       pubDerv.pub_printParentMem();
       cout<<"proDerv:"<<endl;
       proDerv.pub_printParentMem();
       cout<<"priDerv:"<<endl;
       priDerv.pub_printParentMem();
       */
}

        先试图通过PubDerv的对象访问从父类继承来的3个string，在编译前可以想象结果：由与第2级访问（类的普通用户）只能访问公有成员，而3个string中只有base_public_string继承之后认识公有的，所以对另外两个string的访问会报错。（注释掉则可顺利编译运行）
        对于proDerv，由于从父类继承来的是2个string为protected和1个为不可访问，因此都不能通过2级访问去访问。
        同理priDerv，由于从父类继承来的是2个string为private和1个为不可访问，也都不能通过2级访问去访问。
 
        若要通过2级访问访问除public和不可访问以外的成员，则只能通过2级访问访问public成员，间接通过1级访问(public成员)去访问。
   

关于protected成员的访问权限：

        在没有继承的情况下，protected跟private相同。在派生类的时候才出现分化。
        基类对象（自然在类外）不能访问基类的protected成员，派生类中可以访问基类的protected成员。也就是说private成员是不能被继承的，只有public，protected的成员才可以被继承。
        派生类对象如果要访问基类protected成员只有通过派生类对象，派生类不能访问基类对象的protected成员。
        请注意 drived class和drived object：派生类和派生类对象。第一点和第二点都是针对派生类来说的。
        对于第三点总结一句话：只有在派生类中才可以通过派生类对象访问基类的protected成员。

        在派生类内部直接访问protected成员和访问派生类对象基类的protected成员都是可行的。
        
        很多书上都说有派生类的情况下protected的访问权限同public。这种说法是不对的，类内部直接访问没什么区别，但是访问对象基类的protected成员只能是在该类的内部。
        这里只列举了只有一层继承的情况，如果有多重继承的情况，比如三层。那么。中间层的类的内部还可以访问第三层类对象的基类成员，但是不能访问第三层类自己的protected的成员