C++類

C++程序設計允許程式設計師使用類（class）定義特定程序中的數據類型。這些數據類型的實例被稱為對象，這些實例可以包含程式設計師定義的成員變量、常量、成員函數，以及重載的運算符。語法上，類似C中結構體（struct）的擴展，C中結構體不能包含函數以及重載的運算符。

## C 結構體與C++ 類的對比

在 C++ 中，結構體 是由關鍵詞 `struct` 定義的一種數據類型。他的成員和基類默認為公有的（public）。由關鍵詞 `class` 定義的成員和基類默認為私有的（private）。這是C++中結構體和類僅有的區別。

### 聚合類

聚合類是一種沒有使用者定義的構造函數，沒有私有（private）和保護（protected）非靜態數據成員，沒有基類，沒有虛函數。這樣的類可以由封閉的大括號用逗號分隔開初始化列表。下列的代碼在 C 和 C++ 具有相同的語法：

```cpp
struct C
{
  int a;
  double b;
};

struct D
{
  int a;
  double b;
  C c;
};

// initialize an object of type C with an initializer-list
C c = { 1, 2 };

// D has a sub-aggregate of type C. In such cases initializer-clauses can be nested
D d = { 10, 20, { 1, 2 } };
```

### POD 結構

一個POD結構（普通舊式數據結構）是一個不包含非POD結構、非POD聯合（或者這些類型的陣列）或引用的非靜態成員變量（靜態成員沒有限制），並且沒有使用者定義的賦值運算符和析構器的聚合類。一個POD結構可以說是C `struct`在C++中的等價物。在大多數情況下，一個POD結構擁有和一個在C中聲明的對應的結構相同的記憶體布局。因此，POD結構有時不正式地被稱為「C風格結構」（C-style struct）。

#### C結構與C++ POD結構共有的屬性

- 數據成員被分配使得一個對象中之後的成員有著更高的地址，除非跨越了一個訪問描述符。
- 兩個POD結構類型是布局兼容的如果它們有相同數量的非靜態數據成員，而且對應的非靜態數據成員（按照順序）是布局兼容的。
- 一個POD結構可以包含未命名的填充。
- 一個指向POD結構對象的指針適合使用`reinterpret_cast`，指向其初始成員而且反之亦然，說明在POD結構的頭部不存在填充。
- 一個POD結構可以被`offsetof`宏使用。

## 聲明和使用

C++ 的結構體和類具有他們自己的成員。這些成員包括變量（包括其他結構體和類），被看做方法的函數（特定的標示符或重載的運算符），構造函數以及析構函數。成員被聲明成為公共或私有使用說明符`public:`和`private:`來區分。說明符後出現的任何成員會獲得相應的訪問權限直到下一個說明符的出現。對於繼承的類能夠使用`protected:`說明符。

### 基本聲明和成員變量

類和結構體的聲明使用關鍵詞`class`和`struct`。成員在類和結構體的內部聲明。

下面的代碼段實例了結構體和類的聲明：

```cpp
struct person
{
  string name;
  int age;

};


```

```cpp
class person
{
public:
  string name;
  int age;
};
```

以上兩個聲明在功能上是等價的。每一段代碼都定義了一個類型`person`，其含有兩個成員變量：`name`和`age`。注意，大括號後面的分號是必需的。

在其中一個聲明之後（不能同時使用兩個），`person`可以被用來定義新的`person`類型的變量：

```cpp
#include <iostream>
#include <string>
using namespace std;

class person
{
public:
  string name;
  int age;
};

int main ()
{
  person a, b;
  a.name = "Calvin";
  b.name = "Hobbes";
  a.age = 30;
  b.age = 20;
  cout << a.name << ": " << a.age << endl;
  cout << b.name << ": " << b.age << endl;
  return 0;
}
```

執行以上代碼將會輸出

```
Calvin: 30
Hobbes: 20
```

### 成員函數

成員函數是C++ 的類和結構體的一個重要特性。這些數據類型可以包含作為其成員的函數。成員函數分為靜態成員函數與非靜態成員函數。靜態成員函數只能訪問該數據類型的對象的靜態成員。而非靜態成員函數能夠訪問對象的所有成員。在非靜態成員函數的函數體內，關鍵詞`this`指向了調用該函數的對象。這通常是通過thiscall調用協議，將對象的地址作為隱含的第一個參數傳遞給成員函數。再次以之前的`person`類型作為例子：

```cpp
class person
{
  std::string name;
  int age;
public:
  person() : age(5) { }
  void print() const;
};

void person::print() const
{
  cout << name << ";" << this->age << endl;
  /* "name"和"age"是成员变量。
     "this"关键字的值是被调用对象的地址。其类型为
     const person*，原因是该函数被声明为const。
  */
}
```

在上面的例子中`print()`函數在類中聲明，並在類的名稱後加上`::`來限定它後加以定義。`name`和`age`是私有的（類的默認修飾符），`print()`被聲明為公有，由於一個被用於類外的成員需要被申明為公有的。

通過使用成員函數`print()`，輸出可以被簡化為：

```cpp
a.print();
b.print();
```

上述的`a`和`b`被稱為調用者（sender），當`print()`函數被執行時每一個都引用自己的成員變量。

將類或結構的申明（稱做接口）和定義（稱作實現）放入分開的單元是常見的做法。使用者需要的接口被放入一個頭文件中而實現則獨立地放入原始碼或者編譯後的形式。

非靜態成員函數，可以用const或volatile關鍵詞限定。const限定的成員函數不能修改其他數據成員（除了具有mutable的例外），也不能調用非const限定的其他成員函數。編譯實現時，通常是在const限定的成員函數體內，this所指向的數據成員自動具有const限定，因此是只讀的。const對象只能調用const成員函數；volatile對象只能調用volatile限定的成員函數。反之，沒有受到限定的普通對象可以調用所有的成員函數，不論它是否為cv限定。構造函數、析構函數不能cv限定。

### 繼承

非POD類的記憶體布局沒有被C++標準規定。例如，許多流行的C++編譯器通過將父類的欄位和子類的欄位並置來實現單繼承，但是這並不被標準所需求。這種布局的選擇使得將父類的指針指向子類的操作是平凡的（trivial）。

例如，考慮：

```cpp
class P
{
    int x;
};
```

```cpp
class C : public P
{
    int y;
};
```

一個`P`的實例和`P* p`指向它，在記憶體中可能看起來像這樣：

```
+----+
|P::x|
+----+
↑
p
```

一個`C`的實例和`P* p`指向它，在記憶體中可能看起來像這樣：

```
+----+----+
|P::x|C::y|
+----+----+
↑
p
```

因此，任何操縱`P`對象的欄位的代碼都可以操縱在`C`對象中的`P`欄位而不需要考慮任何關於`C`欄位的定義。一個正確書寫的C++程序在任何情況下都不應該對被繼承欄位的布局有任何假定。使用static_cast或者dynamic_cast類型轉換運算符會確保指針正確的從一個類型轉換為另一個。

多重繼承並不那麼簡單。如果一個類`D`繼承了`P1`和`P2`，那麼兩個父類的欄位需要被按照某種順序存儲，但是（在大多數情況下）只有一個父類可以被放在子類的頭部。每當編譯器需要將一個指向`D`的指針轉換為`P1`或`P2`中的任一個，編譯器需要提供一個自動轉換從子類的地址轉換為父類欄位的地址（典型地，這是一個簡單的偏移量計算）。

關於多重繼承的更多資訊，參看虛繼承。

### 重載運算符

C++容許程序員重載某些運算符，目的是補充庫中未能提供的針對特定類的運算符。同理，很多時自定類也因為內建庫不能提供指定運算符而需要重載。

另外，當程式設計師沒有重載或定義某些運算符時，編譯器會自動地建立它們，例如三法則中的複製指定運算子（`=`）。

依照慣例，重載運算符時應模擬運算符本身意義的功能，例如重載運算符「*」時，程序員義務重載為兩數之乘法（或其他，視數學或程式上的意義）。另外，宣告一結構如`integer`類，當重載運算符如「*」就要回傳`integer`類：

```cpp
struct integer
{
    int i;
    integer(int j = 0) : i(j) {}
    integer operator*(const integer &k) const
    {
        return integer (i * k.i);
    }
};
```

或

```cpp
struct integer
{
    int i;

    integer(int j = 0) : i(j) {}

    integer operator*(const integer &k) const;
};

integer integer::operator*(const integer &k) const
{
    return integer(i * k.i);
}
```

在這裡，`const`關鍵字出現兩次。表達式`const integer &k`中的`const`關鍵字代表函數不能修改此常數值，而第二個`const`關鍵字代表此函數不會修改類物件本身（`*this`）。

而`integer &k`之中，符號（`&`）表示以參照形式呼叫。當呼叫函數時會直接傳遞變數地址，並以變數本身取代這裡的變數`k`。

#### 二元可重載運算符

二元運算符會用函數方式並以「`operator 運算符`」識別來進行重載，這裡的參數會是單一參數。實際使用時，二元運算符左方的變數會成為類物件本身（`*this`），而右方變數則成為傳入參數。

```cpp
integer a = 1;
/* 這裡的等號是其中一種二元運算符。
   我們可利用重載運算符(=)的方式
   來提供初始化功能，而左方的變數i
   就是類物件本身，右方的數字1則是
   傳入參數。 */
integer b = 3;
/* 變數名字跟類物件內的變數無關 */
integer k = a * b;
cout << k.i << endl;  //輸出3
```

以下是二元可重載運算符列表：

算術運算子

運算子名稱｜語法

加法（總和）｜`a '''+''' b`

以加法賦值｜`a '''+=''' b`

減法（差）｜`a '''-''' b`

以減法賦值｜`a '''-=''' b`

乘法（乘積）｜`a '''*''' b`

以乘法賦值｜`a '''*=''' b`

除法（分之）｜`a '''/''' b`

以除法賦值｜`a '''/=''' b`

模數（餘數）｜`a '''%''' b`

以模數賦值｜`a '''%=''' b`

比較運算子

運算子名稱｜語法

小於｜`a '''&lt;''' b`

小於或等於｜`a '''&lt;=''' b`

大於｜`a '''&gt;''' b`

大於或等於｜`a '''&gt;=''' b`

不等於｜`a '''!=''' b`

等於｜`a '''==''' b`

邏輯 AND｜`a '''&amp;&amp;''' b`

邏輯 OR｜a `||` b

位元運算子

運算子名稱｜語法

位元左移｜`a '''&lt;&lt;''' b`

以位元左移賦值｜`a '''&lt;&lt;=''' b`

位元右移｜`a '''&gt;&gt;''' b`

以位元右移賦值｜`a '''&gt;&gt;=''' b`

位元AND｜`a '''&amp;''' b`

以位元AND賦值｜`a '''&amp;=''' b`

位元OR｜a `|` b

以位元OR賦值｜a `|`= b

位元XOR｜`a '''^''' b`

以位元XOR賦值｜`a '''^=''' b`

其它運算子

運算子名稱｜語法

基本賦值｜`a '''=''' b`

逗號｜`a ''',''' b`

運算符（`=`）可以被用作賦值，意思是原定功能是由右方變數抄寫內部資料到左方變數，但視乎需要也可以被用作其他用途。

每個運算符是互相獨立存在，並不依賴其他運算符。例如運算符（`&lt;`）並不需要運算符（`&gt;`）存在從而運作。

#### 一元可重載運算符

一元運算符跟上述的運算符相似，只是一元運算符只會載入類物件本身（`*this`），而不接受其他參數。另外，一元運算符有分前置運算符和後置運算符，分別在於前置運算符會放到變數前方，後置運算符則是後方。例如負值運算符（`-`）和邏輯取反運算符（`!`）都是一元前置運算符。

以下是一元可重載運算符列表：

算術運算子

運算子名稱｜語法｜類型｜備注

一元正號｜`'''+'''a`｜前置

前綴遞增｜`'''++'''a`｜前置｜先加1並回傳加1後的值

後綴遞增｜`a'''++'''`｜後置｜加1但回傳加1前的值

一元負號（取反）｜`'''-'''a`｜前置

前綴遞減｜`'''--'''a`｜前置｜先減1並回傳減1後的值

後綴遞減｜`a'''--'''`｜後置｜減1但回傳減1前的值

比較運算子

運算子名稱｜語法｜類型

邏輯取反｜`'''!'''a`｜前置

位元運算子

運算子名稱｜語法｜類型

位元一的補數｜`'''~'''a`｜前置

其它運算子

運算子名稱｜語法｜類型

間接（向下參考）｜`'''*'''a`｜前置

位址（參考）｜`'''&amp;'''a`｜前置

轉換｜`(''type'') a`｜前置

重載一元運算符時有區分前置和後置式，一元前置運算符按以下格式編寫：

`回傳資料型態 operator 運算符 ()`

而後置運算符按以下格式編寫：

`回傳資料型態 operator 運算符 (參數)`

#### 括號重載

括號運算符有兩種，分別是方形括號運算符（`[]`）和圓形括號運算符（`()`）。方形括號運算符又名陣列運算符，只能傳入單一參數，而圓形括號運算符卻可以傳入任意數量的參數。

方形括號運算符按以下格式重載：

`回傳資料型態 operator[] (參數)`

圓形括號運算符按以下格式重載：

`回傳資料型態 operator() (參數1, 參數2, ...)`

注意，參數是指定在第二個括號之中，第一個括號只是運算符符號。

### 構造函數

有時軟體工程師會想要他們的變量在聲明時有一個默認值。這可以通過聲明構造函數做到。

```cpp
person(string N, int A)
{
    name = N;
    age = A;
}
```

成員變量可以像下面的例子一樣，利用一個冒號，通過一個初始化序列初始化。這與上面不同，它進行了初始化（使用構造函數），而不是使用賦值運算符。這對類類型來說更有效，因為它只需要直接構造；而賦值時，它們必須先使用默認構造函數進行第一次初始化，然後再賦予一個不同的值。而且一些類型（例如引用和const類型）不能被賦值，因而必須通過初始化序列進行初始化。

```cpp
person(std::string N, int A) : name(N), age(A) {}
```

注意花括號不能被省略，即使為裡面為空。

默認值可以給予最後的幾個參數類幫助初始化默認值。

```cpp
person(std::string N = "", int A = 0) : name(N), age(A) {}
```

在上面的例子中，當沒有參數給予構造函數時，等價於調用以下的無參構造函數（一個默認構造函數）：

```cpp
person() : name(""), age(0) {}
```

構造函數的聲明看起來像一個名字和數據類型相同的函數。事實上，我們的確可以用函數調用的形式調用構造函數。在這種情況下一個`person`類型的變量會成為返回值：

```cpp
int main()
{
    person r = person("Wales", 40);
    r.print();
}
```

以上的例子創建了一個臨時的person對象，然後使用複製構造函數將其賦予r。一個更好的創建對象的方式（沒有不需要的拷貝）：

```cpp
int main()
{
    person r ("Wales", 40);
    r.print ();
}
```

具體的程序行為，可以也可以不和變量有關係，可以被作為一部分加入構造函數。

```cpp
person()
{
    std::cout << "Hello!" << endl;
}
```

通過以上的構造函數，當一個`person`變量沒有被具體的值初始化時，「Hello!」會被列印。

### 默認構造函數

當類沒有定義構造函數時，默認構造函數將被調用。

```cpp
class A { int b;};
//使用括号创建对象
A *a = new A(); //调用默认构造函数，b会被初始化为'0'
//不使用括号创建对象
A *a = new A; //仅分配内存，不调用默认构造函数，b会有一个未知值
```

然而如果使用者定義了這個類的構造函數，兩個聲明都會調用使用者定義的構造函數。而在使用者定義的構造函數中的代碼會被執行，並且不會賦予b默認值。

### 析構函數

一個析構函數是一個構造函數的逆，當一個類的一個實例被銷毀時會被調用，例如當一個類在塊（一組花括號「{}」)中被構造的一個對象會在關閉括號後刪除，之後析構函數被自動調用。它會在清空保存變量的記憶體位置時被調用。析構函數可以在類被銷毀時用來釋放資源，例如堆分配的記憶體和打開的文件。

聲明一個析構函數的符號類似於構造函數。它沒有返回值而且方法的名稱和在類的名稱前加上波浪線（~）相同。

```cpp
~person()
{
    cout << "I'm deleting " << name << " with age " << age << endl;
}
```

另外要注意的是，析構函數是不容許參數傳遞。然而，與構造函數一樣，析構函數可以被顯式調用：

```cpp
int main()
{
    person someone("Wales", 40);
    someone.~person();  //此時會輸出一次"I'm deleting Wales with age 40"

    return 0;  //第二次輸出"I'm deleting  with age 40"
}
/* 在這裡，程式結束時會自動調用析構函數。
   而person.name在第一次調用析構函數時已被清除。
   但person.age會按編譯器而定。
   沒能在第一次調用析構函數時清零。 */
```

## 構造函數與析構函數的相似點

- 兩者都和聲明所在的類別有相同的名字。
- 若未宣告，兩者都會執行預設的行為。意即類別在建立或刪除時，會一同分配或刪除記憶體。
- 對衍生類別（subclass）而言，在基礎類別（superclass）的建構函式執行期間，衍生類別的建構函式還未執行；反之，在基礎類別的解構函式執行期間，衍生類別的解構函式已執行完畢。兩種情況下，都無法使用在衍生類別宣告的變數。

## 類模板

類模板，是對一批僅僅成員數據類型不同的類的抽象，程式設計師只要為這一批類所組成的整個類家族創建一個類模板，給出一套程序代碼，就可以用來生成多種具體的類，這類可以看作是類模板的實例，從而大大提高編程的效率。

## 屬性

C++語法試圖使一個結構的所有方面看起來像一個基本數據類型。因此，運算符重載允許結構像整數和浮點數一樣操作，結構的陣列可以通過方括號聲明（`some_structure variable_name[size]`），而且指向結構的指針可以通過和指向內置類型的指針通用的方法解引用。

### 記憶體消耗

結構的記憶體消耗至少是組成變量的記憶體大小的總和。參考如下`twonums` 結構例子。

```cpp
struct twonums
{
    int a;
    int b;
};
```

這個結構包含兩個整型。在當前許多 C++ 編譯器中，整型默認是32位整型，所以每個成員變量消耗4個字節的記憶體．因而整個結構至少（或者正好）消耗8個字節的記憶體，見下圖。

```
+----+----+
| a  | b  |
+----+----+
```

然而，編譯器可能在變量或者結構的結尾添加空的位，這樣可以保證和給定的電腦結構匹配，通常是把變量添加到32位。如下例子所示的結構:

```cpp
struct bytes_and_such
{
   char c;
   char C;
   short int s;
   int i;
   double d;
};
```

可看成

```
+-+-+--+--+--+--+--------+
|c|C|XX|s |  i  |   d    |
+-+-+--+--+--+--+--------+
```

在記憶體中, XX 表示兩個未被使用的空位元。

因為結構可能會使用指針和陣列去聲明 或者初始化變量，結構的記憶體消耗不一定是固定的。另外一個記憶體消耗不固定的例子是模板結構。

#### 位欄位

位欄位（Bit field）可以被用來定義比內置類型還要小的類成員變量。通過這個欄位定義的變量，只可以像使用內置的整數類型(例如int, char, short, long...)那樣子使用。

```cpp
struct A
{
	unsigned a:2; // 可以存储0-3的数字，占据一个int前2 bit的空间.
	unsigned b:3; // 可以存储0-7的数字，占据之后3 bit的空间.
	unsigned :0;  // 移动到下一个内置类型的末尾
	unsigned c:2;
	unsigned :4;  // 在c和d中间加4bit的空白
	unsigned d:1;
	unsigned e:3;
};

// 内存结构
/*	4 byte int   4 byte int
	[1][2][3][4] [5][6][7][8]
	[1]                   [2]              [3]              [4]
	[a][a][b][b][b][][][] [][][][][][][][] [][][][][][][][] [][][][][][][][]

	[5]                  [6]                [7]              [8]
	[c][c][][][][][d][e] [e][e][][][][][][] [][][][][][][][] [][][][][][][][]
*/
```

位欄位不能在結構體中使用，它只能在使用struct或者class關鍵字定義的類中使用。

### this關鍵字

```cpp
complex& operator+=(const complex & c)
{
    realPart += c.realPart;
    imagPart += c.imagPart;
    return *this;
}
```

## 資料來源

- Cplusplus.com tutorial lesson 5.2, accessed in January 2006
- Chan, S. "Tutorial on C++ and STL", Hong Kong, 2006
- Cplusplus.com tutorial lesson 2.5, accessed in February 2006