C++ 運算式與運算子

運算式

運算式由**運算元（operand）與運算子（operator）**組成，用於執行計算或邏輯操作。運算式的結果具有特定資料型態。

範例

以下均為合法的 C++ 運算式：

-2;             // 一元運算子「-」與常數 2 組成
age + 2;        // 變數 age、算術運算子 + 與常數 2 組成
a * b * c * (d / 3 - 1); // 變數、常數與多個運算子組成

運算子

1. 設定運算子

用於賦值，將右邊的值設定給左邊的變數。

運算子	意義
=	將右邊的值設定給左邊的變數

範例：

int x = 10; // 將 10 設定給變數 x

2. 一元運算子

僅需一個運算元的運算子。

運算子	意義
+	正號（通常省略）
-	負號
!	邏輯否定（布林值取反）
~	位元取補數（將 1 變 0，0 變 1）

範例：

+63;       // 正 63
int b = 5;
-b;        // 負 b，結果為 -5
~b;        // 對 b 進行位元取補數
int a = -b; // 將 -b 的值設定給 a

3. 算術運算子

用於數學運算。

運算子	意義
+	加法
-	減法
*	乘法
/	除法
%	取餘數（僅適用於整數）

練習：整數除法與浮點數除法

#include <iostream>
using namespace std;
int main() {
    int a = 10, b = 3;
    int result = a / b;      // 結果為 3（整數除法，捨去小數）
    float c = 10.0, d = 3.0;
    float result2 = c / d;   // 結果為 3.33333（浮點數除法）
    cout << "int: " << result << ", float: " << result2 << endl;
    return 0;
}

算術與設定運算子的結合 結合算術與設定運算子可簡化程式碼，常用的複合運算子包括 +=, -=, *=, /=, %=。

練習：複合運算子

#include <iostream>
using namespace std;
int main() {
    int a = 100, b = 15;
    cout << "a=" << a << ", b=" << b << endl;
    a -= b; // 等價於 a = a - b
    cout << "after a-=b, a=" << a << ", b=" << b << endl;
    return 0;
}

4. 關係運算子

用於比較兩個運算元，通常搭配條件語句，返回布林值（true 或 false）。

運算子	意義
>	大於
<	小於
>=	大於等於
<=	小於等於
==	等於
!=	不等於

5. 遞增與遞減運算子

用於將變數值增加或減少 1。

運算子	意義
++	遞增，變數值加 1
--	遞減，變數值減 1

i++ 與 ++i 的區別：

• i++（後置遞增）：先使用 i 的值，再將 i 加 1。
• ++i（前置遞增）：先將 i 加 1，再使用新值。
• --i 和 i-- 同理。

練習：後置遞增運算子

#include <iostream>
using namespace std;
int main() {
    int a = 10;
    cout << "a=" << a << endl;
    cout << "a++*2=" << (a++ * 2) << endl; // 先計算 a*2，再將 a 加 1
    cout << "a=" << a << endl;             // a 已變為 11
    return 0;
}

練習：前置遞增運算子

#include <iostream>
using namespace std;
int main() {
    int a = 10;
    cout << "a=" << a << endl;
    cout << "++a*2=" << (++a * 2) << endl; // 先將 a 加 1，再計算 a*2
    cout << "a=" << a << endl;             // a 已變為 11
    return 0;
}

6. 邏輯運算子

用於操作布林值，結合多個條件。

運算子	名稱	意義
!	NOT	取反（true 變 false，反之亦然）
&	AND	兩運算元均為 true 時返回 true
`	`	OR
^	XOR	兩運算元不同時返回 true
&&	AND ALSO	同 &，具短路求值特性
`		`

短路求值：

• ||：若第一運算元為 true，則不評估第二運算元，直接返回 true。
• &&：若第一運算元為 false，則不評估第二運算元，直接返回 false。

7. 位元邏輯運算子

對變數的二進位位元進行操作。

運算子	名稱	意義
~	NOT	位元取補數（1 變 0，0 變 1）
&	AND	兩位元均為 1 時返回 1
`	`	OR
^	XOR	兩位元不同時返回 1
>>	右移	位元右移，左邊補 0（等價於除以 2）
<<	左移	位元左移，右邊補 0（等價於乘以 2）

8. 括號運算子

用於控制運算式的優先順序。

運算子	意義
()	優先計算括號內的運算式

範例：括號的影響

int result1 = 8 - 2 * 3 + 7 * 6;     // 結果為 44（依優先順序計算）
int result2 = 8 - 2 * (3 + 7) * 6;   // 結果為 -112（括號改變優先順序）

9. 運算子優先順序

運算子的執行順序由優先級決定，優先級高的先執行。以下是常見運算子的優先順序（由高到低）：

優先級	運算子	說明	結合方向
1	()	括號	左到右
2	++, --, +, -, !, ~	遞增、遞減、一元正負、邏輯/位元 NOT	右到左
3	*, /, %	乘、除、取餘	左到右
4	+, -	加、減	左到右
5	<<, >>	位元左移、右移	左到右
6	>, <, >=, <=	關係運算子	左到右
7	==, !=	等於、不等於	左到右
8	&	位元 AND	左到右
9	^	位元 XOR	左到右
10	`	`	位元 OR
11	&&	邏輯 AND	左到右
12	`		`
13	=	設定運算子	右到左

注意：使用括號可明確指定運算順序，避免依賴優先級造成的歧義。

型態轉換

1. 隱性資料型態轉換（Implicit Type Conversion）

C++ 會自動進行型態轉換，遵循以下規則：

1. 轉換前後的資料型態相容。
2. 轉換後的型態表示範圍大於轉換前的型態（例如，short 轉為 int）。
3. 轉換僅影響當前運算式，不改變變數本身。
4. 以確保資料精度不損失為原則。

範例：

#include <iostream>
using namespace std;
int main() {
    int a = 45;
    float b = 2.3f;
    cout << "a=" << a << ", b=" << b << endl;
    cout << "a/b=" << a / b << endl; // a 自動轉為 float，結果為 19.5652
    return 0;
}

2. 顯性資料型態轉換（Explicit Type Conversion）

也稱為強制型態轉換，透過指定型態進行轉換。

語法：

(欲轉換的資料型態) 變數名稱;

範例：

float a = 1.0;
int b = (int)a; // 將 a 轉為 int，b = 1

練習：顯性型態轉換

#include <iostream>
using namespace std;
int main() {
    int a = 36, b = 7;
    cout << "a=" << a << ", b=" << b << endl;
    cout << "a/b=" << a / b << endl;              // 結果為 5（整數除法）
    cout << "a/b=" << (float)a / b << endl;       // 結果為 5.14286（轉為浮點數）
    return 0;
}

3. 運算式的型態轉換規則

當運算式中的運算元型態不一致時，C++ 會自動進行型態轉換：

1. 佔用位元組較少的型態轉為位元組較多的型態（例如，short 轉 int）。
2. 若運算式中包含 double 型態，另一運算元轉為 double。
3. 布林型態（bool）不可轉換為其他型態。

範例：

#include <iostream>
using namespace std;
int main() {
    char ch = 'X';   // ASCII 值為 88
    short s = -5;
    int i = 6;
    float f = 9.7f;
    double d = 1.76;
    cout << "(s*ch)-(d/f)*(i+f)=";
    cout << (s * ch) - (d / f) * (i + f) << endl; // 型態自動轉換
    return 0;
}