資料封裝是面向物件程式設計的一個重要特點，它防止函式直接訪問類型別的內部成員。類成員的訪問限制是通過在類主體內部對各個區域標記 public、private、protected 來指定的。關鍵字 public、private、protected 稱為訪問修飾符。一個類可以有多個 public、protected 或 private 標記區域。每個標記區域在下一個標記區域開始之前或者在遇到類主體結束右括號之前都是有效的。成員和類的預設訪問修飾符是 private。

• public 成員在程式中類的外部是可訪問的。您可以不使用任何成員函式來設定和獲取公有變數的值
• protected 成員變數或函式與私有成員十分相似，但有一點不同，protected（受保護）成員在派生類（即子類）中是可訪問的。
• private 成員變數或函式在類的外部是不可訪問的，甚至是不可檢視的。只有類和友元函式可以訪問私有成員

在繼承中的特點：

• public 繼承：基類 public 成員，protected 成員，private 成員的訪問屬性在派生類中分別變成：public, protected, private

• protected 繼承：基類 public 成員，protected 成員，private 成員的訪問屬性在派生類中分別變成：protected, protected, private

• private 繼承：基類 public 成員，protected 成員，private 成員的訪問屬性在派生類中分別變成：private, private, private

但無論哪種繼承方式，上面兩點都沒有改變：

• private 成員只能被本類成員（類內）和友元訪問，不能被派生類訪問；

• protected 成員可以被派生類訪問。

#include <iostream>
 
using namespace std;
 
 class test_A
 {
public:
     int A_public ;

     test_A()
     {
        A_public = 202;
        A_protected = 10;
        A_private = 100;
     }

     void foo()
     {
         cout 
 
<< "A_public : " << A_public << endl;
         cout << "A_protected : " << A_protected << endl;
         cout << "A_private : " << A_private << endl;
     }

protected:
     int A_protected;

private:
     int A_private;

 };

 class test_B : public test_A
 {
public:
     int B_public ;

     test_B(int a)
     {
        test_A();
        B_public = a;
     }

     void foo()
     {
         cout << "B_public : " << B_public << endl;
         cout << "A_public : " << A_public << endl;
         cout << "A_protected : " << A_protected << endl;
        //  cout << "A_private : " << A_private << endl; //這條語句是錯的，繼承類不能訪問父類private成員
     }
 };

  class test_C : protected test_A
 {
public:
     int C_public ;

     test_C(int a)
     {
         test_A();
        C_public = a;
     }

     void foo()
     {
        cout << "C_public : " << C_public << endl;
         cout << "A_public : " << A_public << endl;
         cout << "A_protected : " << A_protected << endl;
        //  cout << "A_private : " << A_private << endl; //這條語句是錯的，繼承類不能訪問父類private成員
     }

 };

   class test_D : private test_A
 {
public:
     int D_public ;

     test_D(int a)
     {
         test_A();
        D_public = a;
     }

     void foo()
     {
        cout << "C_public : " << D_public << endl;
         cout << "A_public : " << A_public << endl;
         cout << "A_protected : " << A_protected << endl;
        //  cout << "A_private : " << A_private << endl; //這條語句是錯的，繼承類不能訪問父類private成員
     }

 };

int main ()
{
 test_A A;
 A.foo();

test_B B(300);
B.foo();

test_C C(400);
C.foo();
// C.A_protected; //protected不能在類外訪問 
// C.A_private; //private不能在類外訪問 

test_D D(500);
D.foo();

   return 0;
}