访问修饰符

访问修饰符

---

---

概述

  C++语言，支持面向对象编程。在面向对象编程中，需要注意设置好数据访问的权限，即防止对数据进行不合理的访问。而C++语言提供了public、protected、private这三个访问修饰符去设置数据的访问权限，即对数据进行封装。
  在类中，通过使用public、protected、private在类中各个区域中进行标记，来指定类成员的访问限制。此外，类成员默认的访问修饰符为private。

---

说明

1. public：

   设置类成员为公有成员，即对于类的外部是可访问的。

2. private：

   设置类成员为私有成员，即对于类的外部是不可访问的。但是对于友元函数或者对于类的内部是可访问的。

3. protected：

   设置类成员为保护成员，对于类的外部，类似于private，是不可访问的。但是，对于该类的派生类（子类）是可访问的。

---

继承中的特点

子类继承父类有三种方式：public、protected、private
这三种继承方式会相应地，改变父类成员的访问限制在子类中的表现，如下表所示
 

继承方式	public	protected	private
public	public	protected	private
protected	protected	protected	private
private	private	private	private

 
注：
1. 表头为父类中类成员的访问修饰符
2. 第一列为子类继承父类的方式
3. 其余单元格为各种继承方式中，父类成员的访问限制在子类中变成何种访问限制

• public 继承

#include <iostream>

using namespace std;

class father {
    public:
        int data1;
    protected:
        int data2;
    private:
        int data3;
    public:
        father():data1(), data2(), data3() { show(); }
        void show()
        {
            cout << "father public data1 : " << data1 << endl; 
            cout << "father protected data2 : " << data2 << endl;
            cout << "father private data3 : " << data3 << endl;
        }
};

class son : public father {  // public 继承 
    public:
        int data;
        son():data() { show(); }
        void show()
        {
            cout << "son data : " << data << endl; 
            cout << "son data1 : " << data1 << endl;  // 父类的public成员，在子类中为public成员 
            cout << "son data2 : " << data2 << endl;  // 父类的protected成员，子类可以访问，在子类中为protected成员 
            cout << "son data3 : " << data3 << endl;  // error，父类的private成员，子类不可以访问，在子类中为private成员 
        }
};

int main()
{   
    son s;
    cout << "s data : " << s.data << endl;
    cout << "s data1 : " << s.data1 << endl;
    cout << "s data2 : " << s.data2 << endl;  // error，protected成员，类外部不能访问 
    cout << "s data3 : " << s.data3 << endl;  // error，private成员，类外部不能访问 
    return 0;
}

• protected 继承

#include <iostream>

using namespace std;

class father {
    public:
        int data1;
    protected:
        int data2;
    private:
        int data3;
    public:
        father():data1(), data2(), data3() { show(); }
        void show()
        {
            cout << "father public data1 : " << data1 << endl; 
            cout << "father protected data2 : " << data2 << endl;
            cout << "father private data3 : " << data3 << endl;
        }
};

class son : protected father {  // protected 继承 
    public:
        int data;
        son():data() { show(); }
        void show()
        {
            cout << "son data : " << data << endl; 
            cout << "son data1 : " << data1 << endl;  // 父类的public成员，在子类中为protected成员 
            cout << "son data2 : " << data2 << endl;  // 父类的protected成员，子类可以访问，在子类中为protected成员 
            cout << "son data3 : " << data3 << endl;  // error，父类的private成员，子类不可以访问，在子类中为private成员 
        }
};

int main()
{   
    son s;
    cout << "s data : " << s.data << endl;
    cout << "s data1 : " << s.data1 << endl;
    cout << "s data2 : " << s.data2 << endl;  // error，protected成员，类外部不能访问 
    cout << "s data3 : " << s.data3 << endl;  // error，private成员，类外部不能访问 
    return 0;
}

• private 继承

#include <iostream>

using namespace std;

class father {
    public:
        int data1;
    protected:
        int data2;
    private:
        int data3;
    public:
        father():data1(), data2(), data3() { show(); }
        void show()
        {
            cout << "father public data1 : " << data1 << endl; 
            cout << "father protected data2 : " << data2 << endl;
            cout << "father private data3 : " << data3 << endl;
        }
};

class son : private father {  // private 继承 
    public:
        int data;
        son():data() { show(); }
        void show()
        {
            cout << "son data : " << data << endl; 
            cout << "son data1 : " << data1 << endl;  // 父类的public成员，在子类中为private成员 
            cout << "son data2 : " << data2 << endl;  // 父类的protected成员，子类可以访问，在子类中为private成员 
            cout << "son data3 : " << data3 << endl;  // error，父类的private成员，子类不可以访问，在子类中为private成员 
        }
};

int main()
{   
    son s;
    cout << "s data : " << s.data << endl;
    cout << "s data1 : " << s.data1 << endl;  // error，private成员，类外部不能访问
    cout << "s data2 : " << s.data2 << endl;  // error，private成员，类外部不能访问 
    cout << "s data3 : " << s.data3 << endl;  // error，private成员，类外部不能访问 
    return 0;
}