C++的关键字public,private和protected

先写最基础的吧。
C进入C++最先碰到的就是class，跟structure很像，但是一开始就多了几个关键字public，private和protected。
下面就我目前自己的理解来说一说。
这几个关键都是修饰class内部成员的访问权限，简单的理解就是：

• 这些都是我的东西，你想要的话，是可以直接拿呢；还是需要我给你一把钥匙先？
• 能直接拿的，那就是public成员。
• 需要钥匙的，那就是private或者protected成员。

不过实际用起来，我理解可以分成两种case：

1. 声明class时，修饰内部成员属性

看一段code：

#include<iostream>
#include<assert.h>
using namespace std;
class A{
public:
    int a;
    A() {
        a1 = 1;
        a2 = 2;
        a3 = 3;
        a = 4;
    }
    void fun() {
        cout << a << endl;        //  在类内部访问，正确
        cout << a1 << endl;       //  内部访问，正确
        cout << a2 << endl;       //  内部访问，正确
        cout << a3 << endl;       //  内部访问，正确
    }
public:
    int a1;
protected:
    int a2;
private:
    int a3;
};
int main() {
    A itema;
    itema.a = 10;       // 在类外部访问public成员a，正确
    itema.a1 = 20;      // 在类外部访问public成员a1，正确
    itema.a2 = 30;      // 在类外部访问protected成员a2，错误，类外不能访问protected成员
    itema.a3 = 40;      // 在类外部访问private成员a3，错误，类外不能访问private成员
    system("pause");
    return 0;
}

由注释可以看到，通过不同的关键字修饰的类成员，其访问权限就有了区别。

小结一下:

• public成员可以在类外部被访问。
• private成员只属于类自己，外部想访问private成员，只能通过类方法。
• protected成员目前的访问属性与private成员一样

2. 类继承时，使基类成员属性在派生类中发生变化

类如果不发生派生，好像就看不出protected和private的区别的，别慌，继续往下走。
因为是3个关键字，所以就有了3种继承方式：

2.1 public继承

刚开始，我是我爸爸生的，我想各方面都跟我爹保持一致，我不想对父类的各个成员属性作任何改变，那么，我就用public继承。
还是看code和注释一目了然：

#include<iostream>
#include<assert.h>
using namespace std;
 
class A {
public:
    int a;
    A() {
        a1 = 1;
        a2 = 2;
        a3 = 3;
        a = 4;
    }
    void fun() {
          cout << a << endl;    // 访问public成员a，正确
          cout << a1 << endl;   // 访问public成员a1，正确
          cout << a2 << endl;   // 类成员函数访问protected成员a2，正确
          cout << a3 << endl;   // 类成员函数访问private成员a3，正确
    }
public:
      int a1;
protected:
      int a2;
private:
      int a3;
};

// 类B public继承 类A，所以，B继承了A的成员a1，a2，属性也完全一样（注：B无法继承A的private成员a3）
class B : public A {                 
public:
      int a;
      B(int i) {
          A();
          a = i;
      }
      void fun() {
          cout << a << endl;        // 正确，访问自己的public成员
          cout << a1 << endl;       // 正确，基类的public成员，在派生类中仍是public成员。
          cout << a2 << endl;       // 正确，基类的protected成员，在派生类中仍是protected,并且可以被派生类访问。
          cout << a3 << endl;       // 错误，基类的private成员不能被派生类访问。(private成员只能由本类的成员访问)
      }
};

int main() {
    B b(10);
    cout << b.a << endl;
    cout << b.a1 << endl;   // 正确，类外可以访问b的public成员a1
    cout << b.a2 << endl;   // 错误，类外不能访问protected成员a2
    cout << b.a3 << endl;   // 错误，类外不能访问private成员
    system("pause");
    return 0;
}

小结一下:

• public继承出来的派生类，基类的成员属性在派生类中不会发生任何变化。
• 派生类无法访问基类的private成员。(我理解为：派生类无法继承基类的private成员，因此派生类就没有这个成员，自然也就无法访问)
• 派生类可以继承基类的protected成员，并且在派生类中，仍然是protected属性。

2.2 protected继承

OK，龙生九子，总有熊孩子。虽然我是我爸爸生出来的，但我爸当年让你直接随便拿的一些东西（苍老师教学片），在我这儿，我不想让你直接取了（我要私藏起来，锁抽屉里，隐私，懂不懂！？），我想变一下，那咋办？
那好办,C++就是这点好，你想要的，它都能给你 : )
那我们就不public继承了嘛，关键字不是还有2个吗，protected也可以用？
那当然了，请看code：

#include<iostream>
#include<assert.h>
using namespace std;
class A {
public:
    int a;
    A() {
        a1 = 1;
        a2 = 2;
        a3 = 3;
        a = 4;
    }
    void fun() {
        cout << a << endl;    // 正确，自己的方法访问自己的成员
        cout << a1 << endl;   //正确
        cout << a2 << endl;   //正确
        cout << a3 << endl;   //正确
    }
public:
    int a1;
protected:
    int a2;
private:
    int a3;
};

// B protected继承 A，那么A的public成员，在B中就“降级”变成protected，protected和private成员属性不变
class B : protected A {
public:
    int a;
    B(int i) {
        A();
        a = i;
    }
    void fun() {
        cout << a << endl;       //正确，B自己的public成员。
        cout << a1 << endl;       //正确，基类的public成员，在派生类中变成了protected，可以被派生类访问。
        cout << a2 << endl;       //正确，基类的protected成员，在派生类中还是protected，可以被派生类访问。
        cout << a3 << endl;       //错误，基类的private成员不能被派生类访问。
    }
};

int main() {
    B b(10);
    cout << b.a << endl;       //正确，对象b自己的的public成员a
    cout << b.a1 << endl;      //错误，b.a1这时候是protected属性，protected成员不能在类外访问。
    cout << b.a2 << endl;      //错误，protected成员不能在类外访问。
    cout << b.a3 << endl;      //错误，private成员不能在类外访问。
    system("pause");
    return 0;
}

你看，这样，爸爸的public片片，在儿子这里，就锁起来了吧！
小结一下：

• protected继承出的派生类，基类的成员属性在派生类中会发生改变。
• 基类的public成员，在派生类中被“降级”成protected。
• 基类的protected成员，在派生类中仍然是protected。
• 基类的private成员，派生类依然无法访问。

2.3 private继承

来到最后一个关键字private。
没有最熊，只有更熊的娃。我爸让你能直接看的所有东西，现在到我这儿，对不起，我都不想再让你直接看了；并且，我还不想给我的儿子继承了！（苍老师只属于我，自己亲儿子也别想！）
那要达到这样的效果，就需要private继承了。
看code：

#include<iostream>
#include<assert.h>
using namespace std;
class A{
public:
    int a;
    A() {
        a1 = 1;
        a2 = 2;
        a3 = 3;
        a = 4;
    }
    void fun() {
        cout << a << endl;    //正确
        cout << a1 << endl;   //正确
        cout << a2 << endl;   //正确
        cout << a3 << endl;   //正确
    }
public:
    int a1;
protected:
    int a2;
private:
    int a3;
};

// B private继承 A，那么在B里，A的public和protected成员都变成了B的private成员
class B : private A {
public:
    int a;
    B(int i) {
        A();
        a = i;
    }
    void fun() {
        cout << a << endl;       //正确，内部访问public成员a。
        cout << a1 << endl;       //正确，基类public成员,在派生类中变成了private,可以被派生类访问。
        cout << a2 << endl;       //正确，基类的protected成员，在派生类中变成了private,可以被派生类访问。
        cout << a3 << endl;       //错误，基类的private成员不能被派生类访问。
    }
};

int main(){
  B b(10);
  cout << b.a << endl;       //正确。b.a是b的public成员
  cout << b.a1 << endl;      //错误，private成员不能在类外访问。
  cout << b.a2 << endl;      //错误, private成员不能在类外访问。
  cout << b.a3 << endl;      //错误，private成员不能在类外访问。
  system("pause");
  return 0;
}

再次小结一下：

• private继承后，基类的public和protected成员，在派生类里都被“降级”成private。
• 访问派生类的private成员，自然遵循private规则。
• 如果有派生类再派生“孙子”类，那么这个“孙子”类将无法访问“爷爷”类和“父亲”类中的任何private成员。

好啦，今天就码到这里，第一次写技术文字，献丑献丑，有谬误之处，请不吝指教，多谢多谢~