1.class（類）

class Drink{//定義飲料類
    public://public下面的東西可以被外面訪問
        char* type;//飲料種類
        double price;//飲料價格
        double volume;//飲料體積
        double currentVolume;//飲料剩余體積
        bool isEmpty();//判是否喝完：成員函數(member function)
        void addDrink(double vol);//添加飲料：成員函數
　　　　　Drink();//初始化函數，用於初始化一杯飲料
 

        ~Drink();//析構函數，用於在不需要這杯飲料時銷毀數據以節省空間
    private://private不能被訪問
        double massOfIngredientA;//A成分的含量
        double massOfIngredientB;//B成分的含量
        double massOfIngredientC;//C成分的含量
};//別忘了最後要加一個分號

當我們需要描述一杯飲料的時候，我們可以如下使用Drink類：

Drink a;//新建一個飲料對象
printf("The Volume Of The Drink is %lf\n
 
",a.volume);

2.public,private,protected的區別^「引用」

在C++中，作用域除了public,private還有protected。那這三者的區別到底是什麽呢？

先來看個示例，就明白了：

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

再來看不是人看的話：

1.類的一個特征就是封裝，public和private作用就是實現這一目的。所以：
用戶代碼（類外）可以訪問public成員而不能訪問private成員；private成員只能由類成員（類內）和友元訪問。
2.類的另一個特征就是繼承，protected的作用就是實現這一目的。所以：
protected成員可以被派生類對象訪問，不能被用戶代碼（類外）訪問。

3.繼承

繼承，顧名思義，就是一個東西把另一個東西的傳統保留下來。

我想要描述一個雪碧對象，雪碧(Sprite)和飲料(Drink)有很多相似之處，我不想重復寫代碼，於是讓Sprite對象繼承Drink對象的屬性。

class Sprite:public Drink
{
       public:
           bool hasBubbles();//返回是否有氣          
}

此處的冒號代表繼承。

現在的Sprite對象除了擁有Drink的全部屬性（volume,currentVolume,price,massOfIngredientA等），還有了獨有的屬性（hasBubble()）;

Q:那麽冒號後的public代表什麽用法呢？

先看看定義：

繼承中的特點：
先記住：不管是否繼承，上面的規則永遠適用！
有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成員可以被派生類訪問。

接下來是三個例子：

　　3.1 public繼承

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

　　3.2 protected繼承

#include<iostream>
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.3 private繼承

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

現在你明白了嗎？

引用：深入理解C++中public、protected及private用法：http://www.jb51.net/article/54224.htm

C++中class(類)與繼承白話學習筆記