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.总结

继承方式	基类成员特性	派生类成员特性	派生类对象访问
public	public	public	可以直接访问
public	protected	protected	不可以直接访问
public	private	private	不可以直接访问
protected	public	protected	不可以直接访问
protected	protected	protected	不可以直接访问
protected	private	private	不可以直接访问
private	public	private	不可以直接访问
private	protected	private	不可以直接访问
private	private	private	不可以直接访问

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;
}