深入理解c++中public，protected，private用法

1.類的一個特徵就是封裝，public和private作用就是實現這一目的。所以：
用戶代碼（類外）可以訪問public成員而不能訪問private成員；private成員只能由類成員（類內）和友元訪問。

2.類的另一個特徵就是繼承，protected的作用就是實現這一目的。所以：
protected成員可以被派生類對象訪問，不能被用戶代碼（類外）訪問。

#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;    //正確
  itema.a1 = 20;    //正確
  itema.a2 = 30;    //錯誤，類外不能訪問protected成員
  itema.a3 = 40;    //錯誤，類外不能訪問private成員
  system("pause");
  return 0;
}

繼承中的特點：
先記住：不管是否繼承，上面的規則永遠適用！
有public, protected, private三種繼承方式，它們相應地改變了基類成員的訪問屬性。

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

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

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

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

1.private成員只能被本類成員（類內）和友元訪問，不能被派生類訪問；
2.protected成員可以被派生類訪問。
再來看看以下代碼：
1.public繼承
代碼如下：

#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;
}

2.protected繼承：
代碼如下：

#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;
}

3**.private**繼承：
代碼如下：

#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;
}

通過以上的代碼都備有較爲詳盡的註釋，讀者應該能夠理解。仔細看代碼中派生類B中定義了和基類同名的成員a，此時基類的a仍然存在，可以驗證。

int main(){
  cout << sizeof(A) << endl;
  cout << sizeof(B) << endl;

  system("pause");
  return 0;
}

輸出：
16
20

所以派生類包含了基類所有成員以及新增的成員，同名的成員被隱藏起來，調用的時候只會調用派生類中的成員。
如果要調用基類的同名成員，可以用以下方法

int main(){

  B b(10);
  cout << b.a << endl;
  cout << b.A::a << endl;

  system("pause");
  return 0;
}

輸出：
10
4
總結：
如果基類是private，不管派生類使用那種訪問說明符，派生類都不能使用

記得這裏是在類外訪問，而a在基類中是public，所以繼承方式應該爲public，使得a在派生類中仍然爲public，在類外可以訪問。
感興趣的讀者可以調試運行一下本文實例，加深印象的同時還會有新的收穫。