執行後輸出結果為何？
1 #include <stdio.h>
2 int main(void) {
3 int a = 2, b = 3, c = 4;
4 int result = a + b * c > 10;
5 printf("%d\n", result);
6 return 0;
7 }選項 A 正確（★ 本題標準答案）
b*c 因為乘法優先順序比加法高，會先算 3*4=12；再算 a+12=2+12=14；最後 14>10 成立，結果為 1（在 C 語言中，關係運算式為真時的值是 1）。
選項 B 錯誤
若照優先順序正確計算，14>10 成立，結果應為 1（真），不是 0（假）。
選項 C 錯誤
14 只是 a+b*c 這個子運算式的中間結果，而 result 儲存的是整個 a+b*c>10 關係運算式的真假值（0或1），不是 14 本身。
選項 D 錯誤
這是完全合法的算術與關係運算混合運算式，不會造成編譯錯誤。
關於 C 語言運算子的優先順序（Precedence）與結合性（Associativity），下列敘述何者正確？
選項 A 錯誤
|| 的優先順序其實比 && 低，所以 a || b && c 會被解讀成 a || (b && c)，而不是 (a || b) && c，這個選項把優先順序描述反了。
選項 B 錯誤
賦值運算子的結合性是「由右而左」，所以 a = b = c; 會先計算 b = c（把 c 的值存入 b），再把這個結果賦值給 a，並不是「先算 a=b 再賦值給 c」。
選項 C 錯誤
關係運算子（如 >、<）的優先順序其實比算術運算子（如 +、-）低，所以 a + b > c 會被解讀成 (a + b) > c，而不是 a + (b > c)，這個選項也把優先順序描述反了。
選項 D 正確（★ 本題標準答案）
* 與 / 優先順序相同，結合性為「由左而右」，因此 a / b * c 會先計算 a / b，再把結果乘以 c，也就是 (a / b) * c。
撰寫者原本的意圖，可能是想要判斷「(a & b) 的結果是否等於 c」，但 C 語言運算子的優先順序，讓行號 4 的判斷式實際上並不是這樣被解讀的。請問實際執行後會印出什麼？
1 #include <stdio.h>
2 int main(void) {
3 int a = 6, b = 3, c = 2;
4 if (a & b == c)
5 printf("YES\n");
6 else
7 printf("NO\n");
8 return 0;
9 }選項 A 錯誤
若真的是先計算 (a & b) 再與 c 比較，結果確實會是 YES，但這並不是 C 語言實際採用的運算順序（見選項 B 的說明）。
選項 B 正確（★ 本題標準答案）
在 C 語言中，== 的優先順序比 & 高，因此行號 4 實際上被解讀成 a & (b == c)：b == c（3==2）為假（0），a & 0 的結果一定是 0（假），所以會執行 else 分支，印出 NO。
選項 C 錯誤
事實正好相反，& 的優先順序比 == 低，不是比較高，因此不會先計算 a & b。
選項 D 錯誤
在同一個 if 判斷式中同時使用 & 與 == 是完全合法的 C 語法，不會造成編譯錯誤，只是結果可能不符合直覺（甚至部分編譯器會針對這種寫法提出警告）。
撰寫者原本可能想要計算「先把 x 左移 2 位，再加 1」（也就是 (x << 2) + 1），但 C 語言運算子的優先順序，讓行號 4 實際計算的並不是這樣。請問 result 印出的值是多少？
1 #include <stdio.h>
2 int main(void) {
3 int x = 1;
4 int result = x << 2 + 1;
5 printf("%d\n", result);
6 return 0;
7 }選項 A 錯誤
若真的先算 (x<<2) 再加 1，結果會是 5；但 C 語言實際運算順序並非如此。
選項 B 正確（★ 本題標準答案）
位移運算子 << 的優先順序其實比加法 + 低，因此行號 4 實際上被解讀成 x << (2 + 1)，也就是 1 << 3，等於 8。
選項 C 錯誤
4 既不是 (x<<2)+1 的結果（應為5），也不是 x<<(2+1) 的結果（應為8），不符合任何一種計算方式。
選項 D 錯誤
這是合法的位移與算術混合運算式，不會造成編譯錯誤。
此程式的撰寫者原本可能想要判斷「score 是否等於 60」，但實際執行後卻印出「及格」，即使 score 原本是 0。請問原因為何？
1 #include <stdio.h>
2 int main(void) {
3 int score = 0;
4 if (score = 60)
5 printf("及格\n");
6 else
7 printf("不及格\n");
8 return 0;
9 }選項 A 錯誤
這不是編譯器的 bug，score = 60 放在 if 判斷式中是完全合法的 C 語法，一般編譯器不會擋下這種寫法（有些會給出提醒性的警告，但不會拒絕編譯）。
選項 B 錯誤
= （賦值）與 == （等於判斷）是意義完全不同的兩個運算子，= 會改變變數的值，== 只是比較兩個值是否相等而不會改變任何變數，兩者不能互相取代。
選項 C 錯誤
0 在 C 語言中被視為「假」而不是「真」；而且此程式的重點在於 score 在判斷之前就已經被 score = 60 重新賦值成 60，並不是用原本的 0 去判斷。
選項 D 正確（★ 本題標準答案）
行號 4 的 score = 60 是「賦值運算」而不是「等於判斷」，這個運算式會把 60 存入 score，而賦值運算式本身的值就是右邊被賦的值（60，非 0），在 if 判斷中被視為真，因此一定會執行 if 分支，印出「及格」。
執行後輸出結果為何？
1 #include <stdio.h>
2 int main(void) {
3 int a = 5;
4 int b = ++a;
5 int c = 5;
6 int d = c++;
7 printf("%d %d %d %d\n", a, b, c, d);
8 return 0;
9 }選項 A 錯誤
c 在 c++ 這個運算式執行完之後就已經遞增為 6（副作用一定會發生），第三個值應該印出遞增後的 c（6），不是遞增前的值（5）。
選項 B 錯誤
b 應該等於遞增後的 a（也就是 6），不是遞增前的值（5）。
選項 C 正確（★ 本題標準答案）
++a 是前置遞增：先把 a 遞增為 6，再把這個新值指定給 b，所以 a=6, b=6；c++ 是後置遞增：先把 c 目前的值（5）指定給 d，再把 c 遞增為 6，所以 c=6, d=5。四個值依序是 6 6 6 5。
選項 D 錯誤
a 是被前置遞增，指定給 b 之前就已經變成 6，所以第一個值應該是 6，不是 5。
關於此程式行號 4 的敘述，下列何者正確？
1 #include <stdio.h>
2 int main(void) {
3 int i = 5;
4 int result = i++ + i++;
5 printf("%d\n", result);
6 return 0;
7 }選項 A 錯誤
這種「先用後加、依序視為 5+5」的假設，忽略了同一運算式中對同一變數做兩次無序列點隔開的遞增，其結果在 C 語言標準中並未被定義，不能保證一定是 10。
選項 B 錯誤
這種「先用 5、第二次用 6」的假設，是把運算元求值順序自行腦補成「由左而右」，但 C 語言標準並未保證 + 兩側運算元的求值順序，也未規定這種寫法的結果，不能保證一定是 11。
選項 C 正確（★ 本題標準答案）
在同一個運算式中，對同一個變數 i 使用了兩次沒有中間序列點（Sequence Point）隔開的遞增運算，這是典型的未定義行為，C 語言標準並未規定其結果，不同編譯器（甚至同一編譯器的不同最佳化設定）可能得到不同的數值。
選項 D 錯誤
同一個變數在同一個運算式中出現兩次，在語法上是合法的（能通過編譯），問題出在其「語意」是未定義行為，而不是語法錯誤。
執行後兩行輸出分別是什麼？
1 #include <stdio.h>
2 int main(void) {
3 int arr[5] = {10, 20, 30, 40, 50};
4 int i = 1;
5 printf("%d\n", arr[i++]);
6 printf("%d\n", i);
7 return 0;
8 }選項 A 錯誤
arr[i++] 使用的是 i 遞增前的值（1）而不是遞增後的值（2）來做索引，所以第一個值不是 arr[0]（10）；而且 i++ 的副作用一定會發生，i 最終一定會變成 2，不會停留在 1。
選項 B 錯誤
i++ 的遞增副作用一定會發生，執行完 arr[i++] 這整個運算式（或這一整行陳述式）之後，i 一定已經變成 2，第二行不會印出未遞增的 1。
選項 C 錯誤
30 是 arr[2] 的值，只有在使用「前置遞增」arr[++i] 時，才會先把 i 遞增成 2 再當作索引；此處使用的是後置遞增 i++，索引用的仍是遞增前的 i（1），所以印出的是 arr[1]（20），不是 arr[2]（30）。
選項 D 正確（★ 本題標準答案）
arr[i++] 會先用 i 目前的值（1）當作陣列索引，所以印出 arr[1]，也就是 20；而這個運算式執行完之後，i 的副作用（遞增）已經發生，i 變成 2，所以第二行印出 2。
執行後輸出結果為何？
1 #include <stdio.h>
2 int main(void) {
3 unsigned char a = 12; // 0000 1100
4 unsigned char b = 10; // 0000 1010
5 printf("%d %d\n", a & b, a | b);
6 return 0;
7 }選項 A 正確（★ 本題標準答案）
a=12（0000 1100），b=10（0000 1010）。逐位元做 AND：0000 1100 & 0000 1010 = 0000 1000 = 8；逐位元做 OR：0000 1100 | 0000 1010 = 0000 1110 = 14。
選項 B 錯誤
22 與 2 並不是 a、b 逐位元做 AND、OR 運算後的正確結果，比較接近把 a、b 直接相加或相減得到的數字，與位元運算的規則不符。
選項 C 錯誤
2 與 8 並非 a & b 與 a | b 依位元運算規則計算出的正確結果組合。
選項 D 錯誤
這個選項把 AND 與 OR 的結果順序對調了：a & b 應該是 8（較小），a | b 應該是 14（較大），不是反過來的 14 與 8。
（假設 unsigned char 占 1 個位元組）執行後兩行輸出分別是什麼？
1 #include <stdio.h>
2 int main(void) {
3 unsigned char a = 5; // 0000 0101
4 printf("%d\n", a ^ a);
5 printf("%d\n", (unsigned char)(~a));
6 return 0;
7 }選項 A 錯誤
a ^ a 對任何 a 而言都一定是 0，不會是 5；這個選項的兩個數字都不符合實際的位元運算結果。
選項 B 錯誤
a ^ a 恆為 0，不會是 10；245 也不是 ~a（轉成 unsigned char）的正確結果（正確應為 250）。
選項 C 正確（★ 本題標準答案）
任何值與自己做 XOR（^）運算，結果一定是 0；~a 是把 0000 0101 每一位元取反，得到 1111 1010，因為題目指定轉型為 unsigned char（無號 8 位元），這個位元樣式對應的無號整數值是 250。
選項 D 錯誤
-6 是把 ~a 的位元樣式解讀成「有號」char 時才會得到的值（二補數 1111 1010 當作有號數即為 -6）；但題目明確要求轉型為 unsigned char，因此應該解讀成無號數 250，不是 -6。
關於位元運算子 << （左移）與 >> （右移）的敘述，下列何者正確？
選項 A 正確（★ 本題標準答案）
對非負整數而言，左移 n 位相當於乘以 2 的 n 次方（在不溢位的前提下），右移 n 位相當於除以 2 的 n 次方並捨去小數，這是位移運算最基本也最常被利用的性質。
選項 B 錯誤
位移運算子完全可以用在 signed（有號）整數上，這是非常常見且合法的寫法，不會產生編譯錯誤。
選項 C 錯誤
不同資料型態的位元寬度不同（例如 char 8 位元、int 32 位元），移出去的位元數量與能保留的結果範圍會因型態而異，並非「與型態完全無關」。
選項 D 錯誤
對「負數」進行右移時，實際行為是實作定義（Implementation-defined），許多編譯器會採用「算術右移」（Arithmetic Shift，以符號位元補位而不是一律補 0），並非保證一律是邏輯右移。
（位元編號由最右邊（最低位）第 0 位開始計算）執行後輸出結果為何？
1 #include <stdio.h>
2 int main(void) {
3 unsigned char flags = 0; // 0000 0000
4 flags = flags | (1 << 2); // 設定第 2 個位元
5 flags = flags | (1 << 4); // 設定第 4 個位元
6 printf("%d\n", flags);
7 return 0;
8 }選項 A 錯誤
6 不符合 flags | (1<<2) | (1<<4) 依位元運算規則計算出的結果（應為 20），比較像是把位元編號或運算方式搞混所得到的錯誤數字。
選項 B 錯誤
24（0001 1000）代表同時設定了第 3 與第 4 個位元，並不符合題目中設定第 2 與第 4 個位元後應該得到的 0001 0100（20）。
選項 C 錯誤
12（0000 1100）代表同時設定了第 2 與第 3 個位元，並不符合題目中第二次設定的其實是第 4 個位元（1<<4），而不是第 3 個位元（1<<3）。
選項 D 正確（★ 本題標準答案）
1 << 2 得到 0000 0100（4），與 flags（0）做 OR 後 flags 變成 0000 0100（4）；接著 1 << 4 得到 0001 0000（16），再與 flags（4）做 OR，得到 0001 0100，也就是 20。
執行後兩行輸出分別是什麼？
1 #include <stdio.h>
2 int main(void) {
3 int a = 4, b = 8;
4 printf("%d\n", a & b);
5 printf("%d\n", a && b);
6 return 0;
7 }選項 A 正確（★ 本題標準答案）
a=4（0100），b=8（1000），逐位元做 AND：0100 & 1000 = 0000，結果為 0；邏輯 AND && 只關心兩個運算元「是否為真（非 0）」，a 與 b 都是非 0（皆為真），所以 a && b 的結果為 1（真）。
選項 B 錯誤
12 是 a+b 的結果，並不是 a & b（位元 AND）依位元運算規則計算出的值；a & b 應該是 0，不是 12。
選項 C 錯誤
a 與 b 都是非 0（真），依邏輯 AND 的定義，a && b 的結果應該是 1（真），不是 0（假）。
選項 D 錯誤
12 與 32 都不是 a & b 或 a && b 依各自運算規則所得到的正確結果，32 比較像是 a*b 的計算方式，與邏輯運算的「非 0 即真」規則不符。
執行後總共會印出幾行文字？其中會不會出現 "called"？
1 #include <stdio.h>
2 int sideEffect(void) {
3 printf("called\n");
4 return 1;
5 }
6 int main(void) {
7 int a = 0;
8 if (a != 0 && sideEffect())
9 printf("true branch\n");
10 printf("done\n");
11 return 0;
12 }選項 A 錯誤
&& 具有短路求值特性，並非「兩邊的運算式都一定會被求值」；當左邊已經足以決定整個運算式的真假時（此處左邊為假），右邊根本不會被求值，因此 sideEffect() 不會被呼叫，也就不會印出 "called"。
選項 B 正確（★ 本題標準答案）
a != 0（0 != 0）為假，依 && 的短路求值特性，右邊的 sideEffect() 完全不會被呼叫（因此不印出 "called"），if 判斷整體為假，也不會進入 if 分支印出 "true branch"；程式最後只會印出一行 "done"。
選項 C 錯誤
若三行都印出，代表 sideEffect() 被呼叫且 if 分支被執行，這與 && 的短路求值特性（左邊為假時右邊不求值）矛盾，不會發生。
選項 D 錯誤
在 if 判斷式中呼叫函式是完全合法且常見的寫法，不會造成編譯錯誤。
關於位元運算子（&、|）與邏輯運算子（&&、||）的差異，下列敘述何者正確？
選項 A 錯誤
如第 13 題所示，位元運算子（&）與邏輯運算子（&&）在同樣的運算元（a=4, b=8）下可以得到不同的結果（0 與 1），兩者運算結果並不永遠相同，也不能完全互相取代。
選項 B 正確（★ 本題標準答案）
邏輯運算子（&&、||）具有短路求值特性：只要左邊運算元已經能決定整個運算式的真假，右邊運算元就不會被求值；而位元運算子（&、|）不具備這種特性，兩個運算元一定都會先被求值，再進行逐位元運算。
選項 C 錯誤
位元運算子可以用在任何整數型態上（包括 char、short、int 等，運算前會先進行整數提升），並不限定只能用於 int。
選項 D 錯誤
&&、|| 等邏輯／關係運算子的運算結果，型態固定是 int（值只會是 0 或 1），與運算元本身的型態無關，不會因為運算元是 char 就讓結果也變成 char。
執行後輸出結果為何？
1 #include <stdio.h>
2 int main(void) {
3 int score = 75;
4 char grade = (score >= 90) ? 'A' : (score >= 80) ? 'B' : (score >= 70) ? 'C' : 'D';
5 printf("%c\n", grade);
6 return 0;
7 }選項 A 錯誤
score=75 並未大於等於 90，所以第一個條件 score >= 90 為假，不會進入這個分支，grade 不會是 'A'。
選項 B 錯誤
score=75 也未大於等於 80，所以 score >= 80 這個條件同樣為假，grade 不會是 'B'。
選項 C 正確（★ 本題標準答案）
依序判斷：score>=90 為假，score>=80 為假，score>=70（75>=70）為真，因此 grade 被設為 'C'。
選項 D 錯誤
只有當前三個條件都為假時，才會走到最後的預設值 'D'；但 score>=70 這個條件已經成立，所以不會走到 'D' 這個分支。
執行後輸出結果為何？
1 #include <stdio.h>
2 int main(void) {
3 int a = 5, b = 10;
4 int result = 1 + a > b ? a : b;
5 printf("%d\n", result);
6 return 0;
7 }選項 A 正確（★ 本題標準答案）
算術運算子 + 與關係運算子 > 的優先順序都比三元運算子 ?: 高，因此行號 4 實際上被解讀成 ((1 + a) > b) ? a : b：先算 1+a=6，再判斷 6>b（6>10）為假，所以取 : 後面的 b，也就是 10。
選項 B 錯誤
6 只是 1+a 這個子運算式的中間結果，並不是整個三元運算式 (1+a>b) ? a : b 最終應該回傳的值。
選項 C 錯誤
5 是 a 的值，只有當 (1+a) > b 這個條件成立時，三元運算式才會回傳 a；但此處條件為假（6 不大於 10），所以不會回傳 5。
選項 D 錯誤
11 是誤以為運算式被解讀成 1 + (a>b?a:b)（也就是誤以為三元運算子的優先順序比 + 還高）才會得到的結果；但實際上 + 的優先順序比三元運算子高，所以不是這樣計算。
（自 C99 起，整數的除法與餘數規則明確規定為「向零捨去」）執行後三行輸出分別是什麼？
1 #include <stdio.h>
2 int main(void) {
3 printf("%d\n", 7 % 3);
4 printf("%d\n", -7 % 3);
5 printf("%d\n", 7 % -3);
6 return 0;
7 }選項 A 錯誤
第二、三行的數字（2、-2）都不是依 C99 規則（餘數正負號跟著被除數）計算出的正確結果。
選項 B 錯誤
第三行應該是 1 而不是 -2；-2 比較接近誤把餘數規則當成「跟著除數」，或是與商（quotient）搞混所得到的錯誤數字。
選項 C 正確（★ 本題標準答案）
7%3：7=2*3+1，餘數為 1。-7%3：C99 起除法向零捨去，-7/3 捨去小數後為 -2，餘數 = -7-(3*-2) = -7+6 = -1（負號跟著被除數 -7）。7%-3：7/-3 捨去小數後為 -2，餘數 = 7-(-3*-2) = 7-6 = 1（正號跟著被除數 7）。三行依序為 1、-1、1。
選項 D 錯誤
第三行 7 % -3 的正確結果是 1（正號跟著被除數 7，而被除數是正的），不是 -1；把正負號誤判成跟著除數（-3）而不是被除數。
關於 C99 標準以後，C 語言整數除法 / 與餘數運算子 % 的規則，下列敘述何者正確？
選項 A 錯誤
C99 標準明確規定整數除法是「向零捨去（Truncate Toward Zero）」，不是「無條件捨去（向下取整，Floor）」；-7/3 向零捨去的結果是 -2，不是 -3（floor 才會得到 -3）。
選項 B 正確（★ 本題標準答案）
這是 C99 標準明確規定的行為：% 運算子的結果，正負號一定與被除數（% 左邊的運算元）相同，這也是「7%-3=1（正號跟著正的 7）」「-7%3=-1（負號跟著負的 -7）」這類結果的理論依據。
選項 C 錯誤
C 語言內建的 % 運算子只能用於整數運算元，不能直接用於 float 或 double；若要對浮點數取餘數，需改用數學函式庫的 fmod()。
選項 D 錯誤
(a/b)*b + a%b == a 這個等式對「任意」整數 a、b（b 不為 0）都成立，這是 C99 標準保證的不變性質，並不限定只有 a、b 都是正整數時才成立。
小明想要寫一個 C 函式，判斷一個整數 n 是否為偶數（Even Number），並且這個函式必須對「負的偶數」（例如 -4）也能正確判斷為偶數。執行後兩行輸出分別是什麼？這個判斷偶數的寫法對負數是否仍然正確？
1 #include <stdio.h>
2 int isEven(int n) {
3 return n % 2 == 0;
4 }
5 int main(void) {
6 printf("%d\n", isEven(-4));
7 printf("%d\n", isEven(-7));
8 return 0;
9 }選項 A 錯誤
自 C99 起，整數 % 運算子對負數運算元的行為是明確定義的（餘數正負號跟著被除數），並不是未定義行為；這個函式的正確性並非巧合，而是有明確的數學與標準依據。
選項 B 錯誤
-4 % 2 的結果是 0（-4 確實整除 2），isEven(-4) 應該回傳 1（真）而不是 0；且「負數對 2 取餘數一定是負的偶數本身」這個說法也不成立（例如 -4%2=0，不是負的偶數本身）。
選項 C 錯誤
% 運算子完全可以用在負數運算元上，這是合法且常見的寫法，不會造成編譯錯誤。
選項 D 正確（★ 本題標準答案）
-4 % 2：-4 可以被 2 整除，商為 -2，餘數為 0，所以 isEven(-4) 為真（1）；-7 % 2：向零捨去商為 -3，餘數為 -7-2*(-3)=-1，不等於 0，所以 isEven(-7) 為假（0）。這個以「% 2 == 0」判斷偶數的寫法，對負偶數依然正確，因為偶數除以 2 一定整除，餘數必為 0，與正負號無關。