1.成员访问权限

假定以下类：

class Base{
public:
    // construct function
    Base(int a = 0,int b = 0, int c = 0) : m_public(),m_protected(),m_private() {}

    int m_public;
    void public_fun() { cout << m_public << endl; }
protected:
    int m_protected;
    void protected_fun() { cout << m_protected << endl; }
private:
    int m_private;
    void private_fun() { cout << m_private << endl; }
};

1.1.public

public为公有类型成员，其内部的变量和函数，任何情况下，在类的外部都可以直接访问。

int main() {
    Base b;
    b.m_public++;
    b.public_fun();
}

1.2.private

private为私有类型成员，其内部的变量和函数，任何情况下，在类的外部都不可以直接访问。

int main() {
    Base b;
    //b.m_private++;      // error
    //b.private_fun();    // error
}

1.3.protected

protected为保护类型成员，通常情况下于private类似，在类的外部都不可以直接访问。

但是被继承时，可以在派生类的函数内访问。

int main() {
    Base b;
    //b.m_protected++;      // error
    //b.protected_fun();    // error
}

2.继承访问权限

1.1.public继承

public继承后，访问基类的变量时，相当于成员类型保持不变。

在派生类内部，可以访问基类的public和protected类型的变量和函数。

在派生类外部，只能访问基类的public类型的变量和函数。

class PublicInherit : public Base
{
public:
    void Test() {
        m_public++;     public_fun();
        m_protected++;  protected_fun();
        //m_private++;  private_fun();    //error
    }
};
int main() {
    PublicInherit Public;
    Public.m_public++;
    Public.public_fun(); 
    return 0;
}

1.2.private继承

private继承后，访问基类的变量时，相当于将全部成员类型都变成private。

在派生类内部，可以访问基类的public和protected类型的变量和函数。

在派生类外部，不能访问基类的的变量和函数。

class PrivateInherit: private Base
{
public:
    void Test() {
        m_public++;     public_fun();
        m_protected++;  protected_fun();
        //m_private++;  private_fun();    //error
    }
};
int main() {
    PrivateInherit Private;
    //Private.m_public++;      //error
    //Private.public_fun();    //error
    return 0;
}

1.3.protected继承

protected继承后，访问基类的变量时，相当于将public成员类型变成protected，其他不变。

在派生类内部，可以访问基类的public和protected类型的变量和函数。

在派生类外部，不能访问基类的的变量和函数。

class ProtectedInherit : protected Base
{
public:
    void Test() {
        m_public++;     public_fun();
        m_protected++;  protected_fun();
        //m_private++;  private_fun();    //error
    }
};
int main() {
    ProtectedInherit Protected;
    //Protected.m_public++;      //error
    //Protected.public_fun();    //error
    return 0;
}

2.4.总结

3.结构体和类的默认权限

3.1.结构体

结构体默认全部权限为public。

注：结构体也可以使用public、private、protected来强制设置访问权限。

struct Struct {
    int m_member;
    void func() { cout << m_member << endl; }
};
int main() {
    Struct s;
    s.m_member++; 
    s.func();     
    return 0;
}

3.2.类

类默认全部权限为private。

class Class {
    int m_member;
    void func() { cout << m_member << endl; }
};
int main() {
    Class c;
    //c.m_member++; //error
    //c.func();     //error
    return 0;
}