1.封裝，public,private作用就是這個目的。

　　類外只能訪問public成員而不能方位private成員；

　　private成員只能被類成員和友元訪問；

2.繼承，protected的作用就是這個目的；

　　protected成員可以被子類對象訪問，但不能被類外的訪問；

3.公有繼承：class A : public B

#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;
};
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成員不能被派生類訪問。
  }
};
int main(){
  B b(10);
  cout << b.a << endl;　　 //正確
  cout << b.a1 << endl;   //正確
  cout << b.a2 << endl;   //錯誤，類外不能訪問protected成員
  cout << b.a3 << endl;   //錯誤，類外不能訪問private成員
  system("pause");
  return 0;
}

4.保護繼承

#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;
};
class B : protected A{
public:
  int a;
  B(int i){
    A();
    a = i;
  }
  void fun(){
    cout << a << endl;       //正確，public成員。
    cout << a1 << endl;       //正確，基類的public成員，在派生類中變成了protected，可以被派生類訪問。
    cout << a2 << endl;       //正確，基類的protected成員，在派生類中還是protected，可以被派生類訪問。
    cout << a3 << endl;       //錯誤，基類的private成員不能被派生類訪問。
  }
};
int main(){
  B b(10);
  cout << b.a << endl;       //正確。public成員
  cout << b.a1 << endl;      //錯誤，protected成員不能在類外訪問。
  cout << b.a2 << endl;      //錯誤，protected成員不能在類外訪問。
  cout << b.a3 << endl;      //錯誤，private成員不能在類外訪問。
  system("pause");
  return 0;
}

5.私有繼承

#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;
};
class B : private A{
public:
  int a;
  B(int i)
  {
    A();
    a = i;
  }
  void fun(){
    cout << a << endl;        //正確，public成員。
    cout << a1 << endl;       //正確，基類public成員,在派生類中變成了private,可以被派生類訪問。
    cout << a2 << endl;       //正確，基類的protected成員，在派生類中變成了private,可以被派生類訪問。
    cout << a3 << endl;       //錯誤，基類的private成員不能被派生類訪問。
  }
};
int main(){
  B b(10);
  cout << b.a << endl;        //正確。public成員
  cout << b.a1 << endl;       //錯誤，private成員不能在類外訪問。
  cout << b.a2 << endl;       //錯誤, private成員不能在類外訪問。
  cout << b.a3 << endl;       //錯誤，private成員不能在類外訪問。
  system("pause");
  return 0;
}

總結：

　　protected，是指子類可以訪問類成員，但是不能被外部訪問；

C++之共有繼承、保護繼承、私有繼承