From Gossip@caterpillar

C++ Gossip: 簡介類別（Class）

class是C++中用來封裝資料的關鍵字，當您使用類別來定義一個物件（Object）時，您考慮這個物件可能擁有的「屬性」（Property）與 「方法」（Method），屬性是物件的靜態描述，而方法是可施加於物件上的動態操作，您使用類別定義出這個物件的規格書，之後就可依這個規格書製作出一 個個的物件實例，並在製作過程中設定個別物件的專屬特性資料。

舉個例子來說，您可以定義一個「球」的模子，考慮球有各種不同的顏色（或名稱），以及球最基本的球半徑資訊，您想到這些資訊應該可以取得，並可以進一步取 得球的體積，當您在C++中要包裝這些資訊時，您可以如下進行定義：
  • Ball.h
#include <string>
using namespace std;

class Ball { 
public: 
    Ball(); 
    Ball(double, const char*); 
    Ball(double, string&); 
 
    double radius();
    string& name(); 
 
    void radius(double); 
    void name(const char*); 
    void name(string&); 
 
    double volumn(); 

private:
    double _radius; // 半徑 
    string _name; // 名稱 
};

您在表頭檔案中定義類別，表頭檔案的名稱建議與類別名稱同名，一個定義良好的類別，即使在不看程式碼實作的情況下，也可以從定義中看出這個類別的大致功 能；class是C++中用來定義類別的關鍵字，Ball是我們取得類別名稱，記得一個類別的定義是這麼作的：
class Ball {
    // 成員定義
};

最重要的是別忘了在最後加上分號，初學C++的新手很常犯這個錯誤；接下來定義類別的成員，注意到public這個關鍵字，它表示以下所定義的成員可以使 用物件名稱直接被呼叫，也稱之為「公用成員」或「公開成員」，private關鍵字下的則是「私用成員」或「私有成員」，不可以透過物件名稱直接呼叫。

在類別封裝時，有一個基本原則是：資訊的最小化公開。如果屬性可以不公開就不公開，如果要取得或設定物件的某些屬性，也是儘量透過方法成員來進行。

資訊的最小化公開原則是基於安全性的考量，避免程式設計人員隨意操作屬性成員而造成程式的錯誤，您可以在日後的程式設計中慢慢來體會；在稍後的實作中，您 將可以看到，我將不會radius與name兩個私用成員直接進行存取，而是透過公開的方法來進行設定。

接下來實作類別的內容：
  • Ball.cpp
#include <string>
#include "Ball.h"
using namespace std;

// 預設建構函式
Ball::Ball() {
    _radius = 0.0; 
    _name = "noname ball"; 
}

Ball::Ball(double radius, const char *name) { 
    _radius = radius; 
    _name = name;
}

Ball::Ball(double radius, string &name) { 
    _radius = radius; 
    _name = name;
}

double Ball::radius() { 
    return _radius; 
} 

double Ball::volumn() { 
    return (4 / 3 * 3.14159 * _radius * _radius * _radius); 
} 

string& Ball::name() { 
    return _name; 
} 

void Ball::radius(double radius) { 
    _radius = radius; 
} 

void Ball::name(string &name) { 
    _name = name; 
}

void Ball::name(const char *name) { 
    _name = name; 
}

類別的實作檔案通常與類別名稱同名，如此例中的Ball.cpp，與類別名稱同名的方法稱之為「建構函式」（Constructor），也有人稱之為「建 構子」，它沒有傳回值，建構函式的作用在於物件生成時自動初始一些必要的資訊，它可以被過載，以滿足物件生成時不同的設定條件。

「::」稱之為類別範圍解析（Class scope resolution）運算子，在實作類別方法時，在::之前指明您要實作的是哪一個類別的方法，您在實作中過載了建構函式，在不指定引數的情況下，會將 radius設定為0，而name設定為"noname ball"，另兩個建構函式則可以指定引數，無參數數建構函式是預設建構函式，如果您沒有定義預設建構函式，則編譯器會自動幫您產生一個無實作內容的預設 建構函式。

定義好類別之後，您就可使用這個類別來建立物件，例如：
Ball ball1;
Ball ball2(5.0, "black ball");
string name("yellow ball");
Ball ball3(10.0, name);

也可以這麼建立物件：
Ball ball1 = Ball(5.0, "black ball");

這有些類似宣告變數，使用類別建立的變數稱其為「物件」（Object）或「實例」（Instant），在上例中就是ball1、ball2與ball3 三個物件，ball1物件在建立時並不指定任何參數，所以根據之前實例建構函式的內容，b1的radius將設定為0.0，name設定為"noname ball"；ball2則給定兩個參數，所以ball2的radius設定為5.0，而ball2的name設定為"black ball"；ball3則是給定radius引數為10.0，第二個參數則給定string實例。

您可以透過公開成員來操作物件或取得物件資訊，方法是使用物件名稱加上「.」運算子，例如：
ball1.name("green ball");
cout << ball1.name() << endl;

以下是使用Ball類別的一個實際例子：
  • main.cpp
#include <iostream> 
#include "Ball.h"
using namespace std; 

int main() {
    Ball ball1;
    cout << ball1.name() << "\t"
         << ball1.volumn() 
         << endl;
 
    ball1.name("green ball");
    ball1.radius(2.5);
    cout << ball1.name() << "\t"
         << ball1.volumn() 
         << endl;

    Ball ball2(5.0, "black ball");
    cout << ball2.name() << "\t"
         << ball2.volumn() 
         << endl; 
 
    string name("yellow ball");
    Ball ball3(10.0, name);
 
    cout << ball3.name() << "\t"
         << ball3.volumn() 
         << endl;
 
    return 0; 
}

執行結果：
noname ball     0
green ball         49.0873
black ball          392.699
yellow ball       3141.59

對於簡單的成員函式，您可以將之實作於類別定義中，在類別定義中即實作的函式會自動成為inline函式，例如：
  • Ball.h
#include <string>
using namespace std;

class Ball { 
public: 
    Ball(); 
    Ball(double, const char*); 
    Ball(double, string&); 
 
    // 實作於類別定義中的函式會自動inline
    double radius() {
        return _radius;
    }
 
    string& name() {
        return _name; 
    }
 
    void radius(double radius) {
        _radius = radius;
    } 
 
    void name(const char *name) {
        _name = name;
    }
 
    void name(string& name) {
        _name = name;
    }
 
    double volumn() {
        return (4 / 3 * 3.14159 * _radius * _radius * _radius); 
    }
 
private:
    double _radius; // 半徑 
    string _name; // 名稱 
};

  • Ball.cpp
#include <string>
#include "Ball.h"
using namespace std;

// 預設建構函式
Ball::Ball() {
    _radius = 0.0; 
    _name = "noname ball"; 
}

Ball::Ball(double radius, const char *name) { 
    _radius = radius; 
    _name = name;
}

Ball::Ball(double radius, string &name) { 
    _radius = radius; 
    _name = name;
}

在定義類別時，如果您只是需要使用到某個類別來宣告指標或是參考，但不涉及類別的生成或操作等訊息，則您可以作該類別的前置宣告（Forward declaration），而不用含入該類別的定義，例如：
  • Test.h
class Ball;

class Test { 
public:
    Test();
    Test(Ball*); 
 
    Ball* ball(); 
    void ball(Ball*);

private:
    Ball *_ball; // 名稱 
};

在定義Test類別時，您尚未真正使用Ball來建構物件進行操作，您只是用它來宣告一些名稱，則您只要使用前置宣告就可以了，實際實作類別時再含入 Ball.h表頭檔即可，例如：
  • Test.cpp
#include "Test.h"
#include "Ball.h"

Test::Test() { 
    _ball = new Ball;
}

Test::Test(Ball *ball) {
    _ball = ball;
}

Ball* Test::ball() {
    return _ball;
}

void Test::ball(Ball *ball) {
    _ball = ball; 
}

如果您的類別定義有單一參數的建構函式（或除了第一個參數之外，其它參數都有預設值的建構函式），則預設會有自動轉換的作用，例如：
class Ball {
public:
    Ball(const char*);
   ...
};

則您可以使用以下的方式來建構物件並初始化：
Ball ball = "Green ball";

預設的轉換行為是由編譯器施行的，但有時是有危險的，如果您不希望編譯器自作主張，則您可以使用explicit修飾，告訴編譯器不要自作主張：
class Ball {
public:
    explicit Ball(const char*);
   ...
};