先写最基础的吧。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成员。