C++中的public private protected

这三个关键字的作用主要体现在两个方面

成员权限访问

    public:可以被任意实体访问
    protected:只允许子类及本类的成员函数访问
    private:只允许本类的成员函数访问

类继承方式

    public 继承   
    protect 继承
    private 继承

 基类中      继承方式             子类中

    public     ＆ public继承        => public
    public     ＆ protected继承     => protected   
    public     ＆ private继承       => private

    protected  ＆ public继承        => protected
    protected  ＆ protected继承     => protected   
    protected  ＆ private继承       => private

    private    ＆ public继承        => 子类无权访问
    private    ＆ protected继承     => 子类无权访问
    private    ＆ private继承       => 子类无权访问

由以上组合结果可以看出

    1、public继承不改变基类成员的访问权限
    2、private继承使得基类所有成员在子类中的访问权限变为private
    3、protected继承将基类中public成员变为子类的protected成员，其它成员的访问       权限不变。
    4、基类中的private成员不受继承方式的影响，子类永远无权访问。

    此外，在使用private继承时，还存在另外一种机制：准许访问。

    我们已经知道，在基类以private方式被继承时，其public和protected成员在子类中变为private成员。然而某些情况下，需要在子类中将一个或多个继承的成员恢复其在基类中的访问权限。

    C++支持以两种方式实现该目的

    方法一，使用using 语句，这是C++标准建议使用的方式
    方法二，使用访问声明，形式为 base-class::member;，位置在子类中适当的访问声明处。(注，只能恢复原有访问权限，而不能提高或降低访问权限)

using namespace std;

class Grand
{
public:
    void public_foo (){}
protected:
    void protected_foo(){}
private:
    void private_foo(){}
};

class Father:public Grand
{
public:
    void f_public_test()        {public_foo();    }   
    void f_protected_test()        {protected_foo(); }    
//    void f_private_test()        {private_foo();   }    
};

class Child:public Father
{
public:
    void c_protected_test()        {protected_foo();  }
//    void c_private_test()        {private_foo();}
};


int main( int argc, char* argv[])
{
    Father  objF;

//    objF.protected_foo();

    return 1;

}


    
    

//protected.cpp

#include <iostream>

using namespace std;

class Grand
{
public:
    void public_foo (){}
protected:
    void protected_foo(){}
private:
    void private_foo(){}
};

class Father:protected Grand
{
public:
    void f_public_test()        {public_foo();    }   
    void f_protected_test()        {protected_foo(); }    
//    void f_private_test()        {private_foo();   }    
};

class Child:public Father
{
public:
    void c_protected_test()        {protected_foo();  }
//  void c_private_test()        {private_foo();}
};


int main( int argc, char* argv[])
{
    Father  objF;


//    objF.public_foo();
//    objF.protected_foo();

    return 1;

}



//private.cpp

#include <iostream>

using namespace std;

class Grand
{
public:
    void public_foo (){}
protected:
    void protected_foo(){}
private:
    void private_foo(){}
};

class Father:private Grand
{
public:
    void f_public_test()        {public_foo();    }   
    void f_protected_test()        {protected_foo(); }    
//    void f_private_test()        {private_foo();   }    
};

class Child:public Father
{
public:
//    void c_protected_test()        {protected_foo();  }
//    void c_private_test()        {private_foo();}
};


int main( int argc, char* argv[])
{
    Father  objF;

//    objF.public_foo();
//    objF.protected_foo();

    return 1;

}