2024年3月全國計算機等級考試真題（二級C語言）

😀 第1題

下列敘述中正確的是

A. 矩陣是非線性結構 ????????B. 數組是長度固定的線性表

C. 對線性表只能作插入與刪除運算 ????????D. 線性表中各元素的數據類型可以不同

題目解析：

A. 矩陣是非線性結構
錯誤。矩陣通常是二維數組，屬于線性結構，因為其元素在內存中是按順序存儲的。

B. 數組是長度固定的線性表
正確。數組是一種線性表，且其長度在定義時固定，無法動態改變。

C. 對線性表只能作插入與刪除運算
錯誤。線性表不僅支持插入和刪除，還支持查找、修改等操作。

D. 線性表中各元素的數據類型可以不同
錯誤。線性表中的元素數據類型必須相同，這是線性表的基本特性。

😀 第2題

在快速排序法中，每經過一次數據交換（或移動）后

A. 能消除多個逆序 ????????B. 只能消除?個逆序

C. 不會產生新的逆序 ????????D. 消除的逆序個數?定比新產生的逆序個數多

題目解析：

在快速排序法中，每經過一次數據交換（或移動）后：

A. 能消除多個逆序
正確。快速排序通過選取基準元素，將數組分為兩部分，使得左邊的元素都小于基準，右邊的元素都大于基準。這樣一次交換可以消除多個逆序。

B. 只能消除一個逆序
錯誤。快速排序的一次交換通常可以消除多個逆序，而不僅僅是一個。

C. 不會產生新的逆序
錯誤。快速排序的過程中可能會產生新的逆序，尤其是在分區過程中。

D. 消除的逆序個數一定比新產生的逆序個數多
錯誤。雖然快速排序的效率較高，但并不能保證每次交換后消除的逆序個數一定比新產生的逆序個數多。

😀 第3題

線性表的長度為n。在最壞情況下，比較次數為n-1的算法是

A. 順序查找 ????????B. 有序表的插入

C. 尋找最大項 ????????D. 同時尋找最大項與最小項

題目解析：

線性表的長度為?n。在最壞情況下，比較次數為?n?1 的算法是：

A. 順序查找
錯誤。順序查找在最壞情況下需要比較?n?次（查找失敗時）。

B. 有序表的插入
錯誤。有序表的插入在最壞情況下需要比較?n?次（插入到表頭時）。

C. 尋找最大項
正確。尋找最大項需要遍歷整個線性表，比較次數為?n?1 次。

D. 同時尋找最大項與最小項
錯誤。同時尋找最大項和最小項的最優算法比較次數為??3n/2??2，而不是?n?1。

😀 第4題

設某棵樹的度為3，其中度為2、1、0的結點個數分別為3、4、15。則該樹中總結點數為

A. 22 ????????B. 30 ????????C. 35 ????????D. 不可能有這樣的樹

題目解析：

😀 第5題

下列敘述中正確的是

A. 軟件的使用存在老化問題 ????????B. 軟件是物理實體，不具有抽象性

C. 軟件是邏輯實體，具有抽象性 ????????D. 軟件的運行對計算機系統不一定具有依賴性

題目解析：

A. 軟件的使用存在老化問題
錯誤。軟件不會像硬件一樣老化，但可能會因為環境變化（如操作系統更新）而變得不兼容或需要更新。

B. 軟件是物理實體，不具有抽象性
錯誤。軟件是邏輯實體，具有抽象性，而不是物理實體。

C. 軟件是邏輯實體，具有抽象性
正確。軟件是邏輯實體，其本質是代碼和算法，具有高度的抽象性。

D. 軟件的運行對計算機系統不一定具有依賴性
錯誤。軟件的運行依賴于計算機系統（如操作系統、硬件等），沒有計算機系統，軟件無法運行。

😀 第6題

軟件系統總體結構圖的作用是

A. 描述軟件系統結構的圖形公具 ????????B. 描述軟件系統的控制流

C. 描述軟件系統的數據流 ????????D. 描述軟件系統的數據結構

題目解析：

軟件系統總體結構圖的作用是：

A. 描述軟件系統結構的圖形工具
正確。軟件系統總體結構圖用于描述系統的模塊劃分、模塊之間的關系以及系統的層次結構，是一種圖形化的表示工具。

B. 描述軟件系統的控制流
錯誤。控制流通常由程序流程圖或狀態圖描述，而不是總體結構圖。

C. 描述軟件系統的數據流
錯誤。數據流通常由數據流圖（DFD）描述，而不是總體結構圖。

D. 描述軟件系統的數據結構
錯誤。數據結構通常由類圖、ER圖等描述，而不是總體結構圖。

😀 第7題

下面不屬于結構化程序設計風格的是

A. 程序結構良好 ????????B. 程序的易讀性 ????????C. 不濫用Goto語句 ????????D. 程序的執行效率

題目解析：

結構化程序設計風格強調程序的可讀性、可維護性和良好的程序結構，而不是單純追求執行效率。

A. 程序結構良好
屬于。結構化程序設計強調程序結構的清晰性和模塊化。

B. 程序的易讀性
屬于。結構化程序設計注重代碼的可讀性，便于理解和維護。

C. 不濫用Goto語句
屬于。結構化程序設計主張避免使用Goto語句，以保持程序結構的清晰性。

D. 程序的執行效率
不屬于。執行效率通常與算法優化和硬件性能相關，而不是結構化程序設計的核心目標。

😀 第8題

將數據庫的結構劃分成多個層次，是為了提高數據庫的物理獨立性和

A. 規范程度 ????????B. 操作獨立性 ????????C. 邏輯獨立性 ????????D. 降低數據冗余

題目解析：

數據庫的結構劃分成多個層次（如外模式、概念模式和內模式），主要是為了提高數據庫的物理獨立性和邏輯獨立性。

A. 規范程度
錯誤。規范程度通常通過數據庫設計范式來實現，而不是通過層次劃分。

B. 操作獨立性
錯誤。操作獨立性不是數據庫層次劃分的主要目標。

C. 邏輯獨立性
正確。數據庫的層次劃分可以提高邏輯獨立性，使得應用程序不受數據庫邏輯結構變化的影響。

D. 降低數據冗余
錯誤。降低數據冗余主要通過數據庫設計范式實現，而不是層次劃分。

😀 第9題

學院的每名教師只能屬于一個系，則實體系和實體教師間的聯系是

A. 一對多 ????????B. 多對多 ????????C. 多對一????????D. 一對一

題目解析：

根據題意，學院的每名教師只能屬于一個系，而一個系可以包含多名教師。因此，實體“系”和實體“教師”之間的聯系是：

一個系對應多個教師（“系”到“教師”是一對多）。
一個教師只能屬于一個系（“教師”到“系”是多對一）。

綜合來看，這種關系是?一對多（從“系”到“教師”的角度）。

😀 第10題

定義學生選修課程關系模式SC(S#,Sn,C#,Cn,G)（其屬性分別為學號、姓名、課程號、課程

名、成績）該關系的范式最高達到

A. 1NF ????????B. 2NF ????????C. 3NF ????????D. BCNF

題目解析：

關系模式?SC(S#,Sn,C#,Cn,G) 的屬性分別為學號、姓名、課程號、課程名、成績。

1NF（第一范式）
該關系模式中，每個屬性都是原子值，滿足1NF。
2NF（第二范式）
2NF要求消除部分函數依賴。在該關系模式中：
- 主鍵是?(S#,C#)。
- Sn（姓名）僅依賴于?S#，Cn（課程名）僅依賴于?C#，存在部分函數依賴。
  因此，該關系模式不滿足2NF。
3NF（第三范式）
由于不滿足2NF，自然也不滿足3NF。
BCNF（巴斯-科德范式）
同樣，由于不滿足2NF，也不滿足BCNF。

因此，該關系模式最高滿足1NF。

😀 第11題

在C語言中，以下說法不正確的是（）。

A. 在C程序中，整數和實數都能被準確無誤地表示出來

B. 在C程序中，任何一個變量名都代表存儲器中的?個位置

C. 靜態變量的生存期與整個程序的運行期相同

D. C語言中，任何變量都必須先聲明才能進行引用

題目解析：

A. 在C程序中，整數和實數都能被準確無誤地表示出來
不正確。在C語言中，整數通常可以準確表示，但實數（浮點數）由于存儲精度的限制，可能無法準確表示某些小數（如0.1）。因此，實數并不總是能被準確無誤地表示。

B. 在C程序中，任何一個變量名都代表存儲器中的一個位置
正確。變量名是存儲器中某個位置的標識符。

C. 靜態變量的生存期與整個程序的運行期相同
正確。靜態變量的生存期從程序開始運行到程序結束。

D. C語言中，任何變量都必須先聲明才能進行引用
正確。C語言要求變量必須先聲明后使用。

😀 第12題

?個C語言程序是由（）。

A. ?個主程序和若干子程序組成 ????????B. 函數組成 ????????C. 若干過程組成 ????????D. 若干子程序組成

題目解析：

C語言程序的基本組成單位是函數。一個C語言程序由一個主函數（main函數）和若干其他函數組成。

A. 一個主程序和若干子程序組成
不準確。C語言中沒有“主程序”和“子程序”的概念，而是“函數”。

B. 函數組成
正確。C語言程序由函數組成，包括主函數和其他自定義函數。

C. 若干過程組成
錯誤。C語言中沒有“過程”的概念。

D. 若干子程序組成
錯誤。C語言中沒有“子程序”的概念。

😀 第13題

以下標識符不是關鍵字的是（）。

A. break ????????B. char ????????C. Switch ????????D. return

題目解析：

在C語言中，關鍵字（Keywords）是預定義的保留標識符，具有特殊含義，不能用作變量名或函數名。題目要求找出不是關鍵字的選項。

選項分析：

A.?break

是關鍵字，用于跳出循環或switch語句。

B.?char

是關鍵字，用于聲明字符型變量。

C.?Switch

不是關鍵字。C語言的關鍵字是switch（全小寫），而Switch因首字母大寫，被視為普通標識符（如變量名或函數名）。

D.?return

是關鍵字，用于從函數返回值。

😀 第14題

下列選項中，不能作為合法常量的是（）。

A. 1.234e04 ????????B. 1.234e0.4 ????????C. 1.234e+4 ????????D. 1.234e0

題目解析：

在C語言中，浮點型常量的科學計數法表示需滿足以下規則：

格式：[整數部分].[小數部分]e[指數部分]。
指數部分：必須是整數（可帶正負號，如e+4或e-2），不能是小數。

選項分析：

A.?1.234e04

合法。指數部分是整數（04）。

B.?1.234e0.4

不合法。指數部分為0.4（小數），違反科學計數法規則。

C.?1.234e+4

合法。指數部分是整數（+4）。

D.?1.234e0

合法。指數部分是整數（0）。

😀 第15題

以下不合法的用戶標識符是（）。

A. r3_t3 ????????B. Else ????????C. 6a ????????D. _6

題目解析：

在C語言中，用戶標識符（變量名、函數名等）的命名需遵循以下規則：

組成字符：字母（A-Z/a-z）、數字（0-9）、下劃線（_）。
首字符：必須是字母或下劃線，不能是數字。
區分大小寫：Else與關鍵字else不同。
不能是關鍵字：如int、if等（但Else不是關鍵字）。

選項分析：

A.?r3_t3

合法。符合標識符規則（字母開頭，含數字和下劃線）。

B.?Else

合法。雖與關鍵字else拼寫相似，但C語言區分大小寫，Else不是關鍵字。

C.?6a

不合法。以數字開頭，違反標識符規則。

D.?_6

合法。以下劃線開頭，符合規則。

😀 第16題

下列敘述中正確的是（）。

A. 調用printf()函數時，必須要有輸出項

B. 使用putchar()函數時，必須在之前包含頭文件stdio.h

C. 在C語言中，整數可以以二進制、八進制或十六進制的形式輸出

D. 調節getchar()函數讀入字符時，可以從鍵盤上輸入字符所對應的ASCII碼

題目解析：

選項分析：

A.?調用printf()函數時，必須要有輸出項

錯誤。printf()可以沒有輸出項，例如僅輸出字符串：printf("Hello");。

B.?使用putchar()函數時，必須在之前包含頭文件stdio.h

正確。putchar()是標準I/O函數，需包含stdio.h頭文件，否則編譯器可能無法識別。

C.?在C語言中，整數可以以二進制、八進制或十六進制的形式輸出

部分錯誤。C語言支持八進制（%o）和十六進制（%x）輸出，但沒有直接支持二進制輸出的格式符（需手動實現）。

D.?調節getchar()函數讀入字符時，可以從鍵盤上輸入字符所對應的ASCII碼

錯誤。getchar()讀取的是鍵盤輸入的字符，而非ASCII碼值。例如輸入字符'A'，返回其ASCII碼值（65），但直接輸入數字65會被視為字符'6'和'5'。

關鍵點：

選項B是唯一完全正確的敘述，其他選項均存在錯誤或不嚴謹之處。

😀 第17題

執行以下程序段后，w的值為（）。

int w='A', x=14, y=15;
w=((x || y)&&(w<'a'));

A. -1 ????????B. NULL ????????C. 1 ????????D. 0

解題步驟

1. 初始化變量

首先，初始化三個變量：

w = 'A'：字符?'A'?的 ASCII 碼值為 65。
x = 14
y = 15

2. 表達式解析

我們需要計算?w = ((x || y) && (w < 'a'))。分步解析：

(1) 計算?(x || y)

||?是邏輯或運算符。如果?x?或?y?中至少有一個非零，則結果為?1（真），否則為?0（假）。
x = 14（非零），y = 15（非零），因此?(x || y)?的值為?1。

(2) 計算?(w < 'a')

w = 'A'（ASCII 值為 65），'a'?的 ASCII 值為 97。
比較?65 < 97，結果為真（1）。

(3) 計算?(x || y) && (w < 'a')

&&?是邏輯與運算符。如果兩邊的表達式都為真，則結果為?1，否則為?0。
(x || y) = 1，(w < 'a') = 1，因此?1 && 1?的值為?1。

(4) 賦值給?w

w = 1（將邏輯表達式的結果賦值給?w）。

3. 結果

w?的最終值為?1。

4. 排除其他選項

A. -1：不正確，邏輯運算的結果是?1?或?0，不會出現?-1。
B. NULL：NULL?通常用于指針，此處不適用。
D. 0：不正確，因為?(x || y)?和?(w < 'a')?都為真。

正確答案????????C. 1

😀 第18題

設有定義："long x=123450L;"，則以下能夠正確輸出變量x的是（）。

A. printf("x=%d\n",x); ????????B. printf("x=%id\n",x);

C. printf("x=%dL\n",x); ????????D. printf("x=%ld\n",x);

解題步驟

1. 理解變量類型

x?被定義為?long?類型：long x = 123450L;。
long?是長整型，通常占用 4 字節或 8 字節（取決于系統），其格式化輸出需要用?%ld。

2. 分析?printf?的格式化字符串

printf?的格式化字符串需要匹配變量的類型：

%d：用于?int?類型。
%ld：用于?long?類型。
%id：無效的格式說明符（i?不是合法的格式修飾符）。
%dL：L?會被當作普通字符輸出，而不是格式說明符的一部分。

3. 逐項驗證選項

A.?printf("x=%d\n",x);
- 錯誤：用?%d?輸出?long?類型，可能導致截斷或未定義行為（尤其是?long?和?int?大小不同時）。
B.?printf("x=%id\n",x);
- 錯誤：%id?是無效的格式說明符（i?無意義）。
C.?printf("x=%dL\n",x);
- 錯誤：%d?不匹配?long?類型，且?L?會被當作普通字符輸出（如?x=123450L，但實際是格式不匹配）。
D.?printf("x=%ld\n",x);
- 正確：%ld?是?long?類型的標準格式說明符。

4. 關鍵點

long?類型必須用?%ld?輸出，%d?僅適用于?int。
其他選項要么格式不匹配，要么語法錯誤。

正確答案????????D.?printf("x=%ld\n",x);

😀 第19題

已有定義int a=3;和輸出語句printf("%8x",a);以下正確的敘述是（）。

A. 整型變量的輸出格式符只有%d?種

B. %x是格式符的?種，它可以適用于任何?種類型的數據

C. %x是格式符的?種，其變量的值按十六進制數輸出，但%8x是錯誤的

D. %8x是正確的格式符，其中數字8規定了輸出字段的寬度

解題步驟

1. 分析?printf("%8x", a);?的含義

%x：以十六進制形式輸出整數（無符號）。
%8x：以十六進制形式輸出整數，且最小字段寬度為 8（不足時左側補空格）。
a = 3?的十六進制是?3，因此輸出為?3（共 8 位，左側補 7 個空格）。

2. 逐項驗證選項

A. 整型變量的輸出格式符只有?%d?一種
- 錯誤。整型變量還可以用?%x（十六進制）、%o（八進制）、%u（無符號十進制）等格式符。
B.?%x?是格式符的一種，它可以適用于任何一種類型的數據
- 錯誤。%x?僅適用于整型（如?int、unsigned int），不能用于浮點型或指針等。
C.?%x?是格式符的一種，其變量的值按十六進制數輸出，但?%8x?是錯誤的
- 部分錯誤。%x?確實按十六進制輸出，但?%8x?是正確的（8?是字段寬度修飾符）。
D.?%8x?是正確的格式符，其中數字?8?規定了輸出字段的寬度
- 正確。%8x?表示十六進制輸出，且最小占 8 字符寬度（不足時補空格）。

3. 關鍵點

%x?用于十六進制輸出，%8x?是合法的（8?是寬度修飾符）。
其他選項或片面（A）、或錯誤（B、C）。

正確答案????????D.?%8x?是正確的格式符，其中數字?8?規定了輸出字段的寬度

😀 第20題

若有定義int x,y; 并已正確給變量賦值，則下列選項中與表達式(x-y)?(x++):(y++)中的條件表達式(x-y)等價的是（）。

A. （x-y>0） ????????B. （x-y<0） ????????C. （x-y<0||x-y>0） ????????D. （x-y==0）

解題步驟

1. 理解條件表達式?(x - y) ? (x++) : (y++)

條件運算符?? :?的語法：條件 ? 表達式1 : 表達式2。
如果?條件?為真（非零），執行?表達式1；否則（為零），執行?表達式2。
因此，(x - y)?是條件，其邏輯等價于判斷?(x - y)?是否為非零。

2. 分析?(x - y)?的真值

(x - y)?是一個數值表達式，其作為條件時：
- 如果?x != y（即?x - y?不為零），則?(x - y)?為真。
- 如果?x == y（即?x - y?為零），則?(x - y)?為假。
因此，(x - y)?的邏輯等價于?(x != y)?或?!(x == y)。

3. 對比選項

A.?(x - y > 0)
僅當?x > y?時為真，不完全等價（漏了?x < y?的情況）。
B.?(x - y < 0)
僅當?x < y?時為真，不完全等價（漏了?x > y?的情況）。
C.?(x - y < 0 || x - y > 0)
等價于?(x != y)，與?(x - y)?的真值完全一致。
D.?(x - y == 0)
是?(x - y)?的反義（x == y），不符合。

4. 驗證選項C

(x - y < 0 || x - y > 0)?表示?x < y?或?x > y，即?x != y。
這與?(x - y)?的條件邏輯完全一致：
- x != y?時，(x - y)?非零（真）；
- x == y?時，(x - y)?為零（假）。

5. 排除其他選項

A、B 只覆蓋部分情況；
D 是反向邏輯；
C 是唯一完全等價的選項。

正確答案????????C.?(x - y < 0 || x - y > 0)

😀 第21題

若a、b、c、d都是int型變量且都已經正確賦初值，則以下不正確的賦值語句是（）。

A. a+d; ????????B. a++; ????????C. a=b=c=d=100; ????????D. a=(b=3)+(d=5);

解題步驟

1. 理解“賦值語句”的定義

在C語言中，賦值語句是指對變量賦予新值的語句，通常包含賦值運算符（=、+=、++?等）。
若語句不改變任何變量的值，則不屬于賦值語句。

2. 逐項分析選項

A.?a+d;
- 這是一個表達式語句，計算?a + d?的值，但未將結果賦值給任何變量。
- 雖然語法合法，但不是賦值語句（題目要求找“不正確的賦值語句”，因此它不符合賦值語句的定義）。
- 如果題目問的是“語法錯誤”，A是合法的；但問的是“不正確的賦值語句”，A是正確答案。
B.?a++;
- 這是賦值語句，等價于?a = a + 1;。
- 語法和邏輯均正確。
C.?a=b=c=d=100;
- 這是鏈式賦值，從右向左依次賦值：d=100?→?c=d?→?b=c?→?a=b。
- 語法和邏輯均正確。
D.?a=(b=3)+(d=5);
- 這是合法的賦值語句：先執行?b=3?和?d=5，再計算?3 + 5?并賦值給?a。
- 語法和邏輯均正確。

3. 關鍵點

題目問的是**“不正確的賦值語句”**，而非“語法錯誤”。
a+d;?是表達式語句，未對任何變量賦值，因此不符合賦值語句的定義。
其他選項（B、C、D）均明確修改了變量的值，屬于賦值語句。

4. 排除法

如果題目問的是“語法錯誤”，則所有選項均合法；
但問的是“不正確的賦值語句”，只有 A 不是賦值語句。

正確答案????????A.?a+d;（因為它不是賦值語句，而題目要求找“不正確的賦值語句”。）

😀 第22題

有以下程序

#define F(X,Y)(X)*(Y)
int main()
{int a=3, b=4;printf("%d\n", F(a++, b++));
}

程序運行后的輸出結果是（）。

A. 12 ????????B. 15 ????????C. 16 ????????D. 20

解題步驟

1. 宏展開

宏?F(X,Y)?定義為?(X)*(Y)，因此?F(a++, b++)?會被展開為：

(a++) * (b++)

2. 表達式求值

a++?是后置自增，先使用?a?的值，再自增。
b++?同理，先使用?b?的值，再自增。

因此，表達式?(a++) * (b++)?的計算過程如下：

取?a?的當前值（3）和?b?的當前值（4），計算?3 * 4 = 12。
然后?a?自增為 4，b?自增為 5。

3. 輸出結果

printf?輸出的是?(a++) * (b++)?的計算結果，即?12。

4. 驗證選項

A. 12：正確。
B. 15：錯誤。
C. 16：錯誤。
D. 20：錯誤。

5. 關鍵點

宏是直接替換，因此?F(a++, b++)?展開為?(a++) * (b++)。
后置自增的特性是先取值后自增，因此乘法運算使用的是?a=3?和?b=4。

正確答案????????A. 12

😀 第23題

下面程序的輸出結果是（）。

int main()
{int a[10]={1,2,3,4,5,6,7,8,9,10},*p=a;printf("%d\n",*(p+2));
}

A. 3 ????????B. 4 ????????C. 1 ????????D. 2

解題步驟

1. 理解指針和數組的關系

int a[10] = {1, 2, 3, ..., 10};?定義了一個整型數組?a，包含 10 個元素。
int *p = a;?定義了一個指針?p，并指向數組?a?的首地址（即?a[0]?的地址）。

2. 指針運算

p + 2?表示指針?p?向后移動 2 個?int?的位置（因為?p?是?int*?類型）。
- p?指向?a[0]，p + 1?指向?a[1]，p + 2?指向?a[2]。
*(p + 2)?是解引用操作，獲取?p + 2?指向的值，即?a[2]?的值。

3. 數組下標對應值

a[0] = 1,?a[1] = 2,?a[2] = 3, ...,?a[9] = 10。
因此，*(p + 2)?的值是?a[2] = 3。

4. 輸出結果

printf?輸出?*(p + 2)?的值，即?3。

5. 驗證選項

A. 3：正確。
B. 4：錯誤（a[3]?的值）。
C. 1：錯誤（a[0]?的值）。
D. 2：錯誤（a[1]?的值）。

正確答案????????A. 3

😀 第24題

有以下程序：

#include<stdio.h>
int main()
{int a=6,b=7,m=1;switch(a%2){case 0:m++;break;case 1:m++;switch(b%2){defaut:m++;case0:m++;break;}}printf("%d\n",m);
}

程序運行后的輸出結果是（）。

A. 1 ????????B. 2 ????????C. 3 ????????D. 4

解題步驟

1. 理解變量初始值

a = 6,?b = 7,?m = 1。

2. 外層?switch(a % 2)?分析

a % 2?計算?6 % 2，結果為?0。
執行?case 0:?分支：
- m++：m?從?1?增加到?2。
- break：跳出外層?switch，不會執行?case 1?分支。

3. 關鍵點

由于?a % 2 == 0，直接執行?case 0?分支，m?變為?2?后跳出?switch。
內層?switch(b % 2)?不會被執行（因為外層?case 0?有?break）。

4. 輸出結果

printf?輸出?m?的最終值：2。

5. 驗證選項

A. 1：錯誤（m?至少會自增一次）。
B. 2：正確。
C. 3：錯誤（需要執行內層?switch?才會達到）。
D. 4：錯誤。

正確答案????????B. 2

😀 第25題

有以下程序

#include <stdio.h>int fun(int a, int b) {if (b == 0) return a;else return (fun(--a, --b));
}int main() {printf("%d\n", fun(4, 2));
}

程序的運行結果是（）。

A. 1 ????????B. 2 ????????C. 3 ????????D. 4

解題步驟

1. 理解遞歸函數?fun(a, b)

函數?fun(a, b)?的邏輯：

基線條件（Base Case）：如果?b == 0，直接返回?a。
遞歸條件：否則，返回?fun(--a, --b)（先對?a?和?b?自減，再遞歸調用）。

2. 遞歸調用過程

計算?fun(4, 2)?的詳細過程：

第一次調用：fun(4, 2)
- b = 2 != 0，執行?else?分支。
- 先計算?--a?和?--b，得到?a = 3,?b = 1。
- 遞歸調用?fun(3, 1)。
第二次調用：fun(3, 1)
- b = 1 != 0，執行?else?分支。
- 先計算?--a?和?--b，得到?a = 2,?b = 0。
- 遞歸調用?fun(2, 0)。
第三次調用：fun(2, 0)
- b = 0，滿足基線條件，直接返回?a = 2。

3. 返回值回溯

fun(2, 0)?返回?2?→?fun(3, 1)?返回?2?→?fun(4, 2)?返回?2。
最終?main()?中?printf?輸出?2。

4. 關鍵點

遞歸的終止條件是?b == 0，此時返回當前的?a。
每次遞歸調用前，a?和?b?都會先自減?1。
遞歸的最終結果是?a?的初始值?4?減去?b?的初始值?2，即?4 - 2 = 2。

5. 驗證選項

A. 1：錯誤。
B. 2：正確。
C. 3：錯誤。
D. 4：錯誤。

正確答案????????B. 2

😀 第26題

關于字符常量，以下敘述正確的是（）。

A. 空格不是?個字符常量 ????????B. 字符常量能包含大于?個的字符

C. 單引號中的大寫字母和小寫字母代表的是相同的字符常量

D. 所有的字符常量都可以作為整型量來處理

解題步驟

1. 理解字符常量的定義

在C語言中，字符常量是用單引號括起來的單個字符，例如?'A'、' '（空格）、'1'?等。
字符常量在內存中以對應的ASCII碼值存儲（如?'A'?的值為65），因此可以參與整數運算。

2. 逐項分析選項

A. 空格不是一個字符常量
- 錯誤。空格是一個字符常量，表示為?' '（單引號內有一個空格）。
B. 字符常量能包含大于一個的字符
- 部分錯誤。標準C語言中，字符常量嚴格定義為單個字符（如?'a'）。
- 但某些編譯器支持多字符常量（如?'ab'），其值是依賴實現的（非標準），通常不建議使用。
C. 單引號中的大寫字母和小寫字母代表的是相同的字符常量
- 錯誤。大寫和小寫字母的ASCII碼不同（如?'A'?是65，'a'?是97），它們是不同的字符常量。
D. 所有的字符常量都可以作為整型量來處理
- 正確。字符常量本質是整數（ASCII碼值），因此可以像整數一樣參與運算（如?'A' + 1?得到?66）。

3. 關鍵點

字符常量的本質：是整數（ASCII碼），因此選項D正確。
空格：是合法的字符常量（' '），選項A錯誤。
大小寫字母：ASCII碼不同，選項C錯誤。
多字符常量：非標準特性，選項B不嚴謹。

4. 排除法

A、B、C均有明顯錯誤或局限性，只有D完全正確。

正確答案????????D. 所有的字符常量都可以作為整型量來處理

😀 第27題

下面函數調用語句含有實參的個數為（）。

func((exp1,exp2),(exp3,exp4,exp5));

A. 1 ????????B. 2 ????????C. 3 ????????D. 5

解題步驟

1. 理解逗號運算符

在C語言中，逗號運算符（,）?用于分隔表達式，并返回最后一個表達式的值。例如：

(exp1, exp2)?的值是?exp2。
(exp3, exp4, exp5)?的值是?exp5。

2. 分析函數調用的實參

函數?func?的參數列表如下：

func((exp1, exp2), (exp3, exp4, exp5));

根據逗號運算符的特性：

第一個參數?(exp1, exp2)?的值是?exp2。
第二個參數?(exp3, exp4, exp5)?的值是?exp5。

因此，實際傳遞給?func?的實參是?exp2?和?exp5，共?2個實參。

3. 驗證選項

A. 1：錯誤（忽略了第二個括號內的逗號運算）。
B. 2：正確（exp2?和?exp5）。
C. 3：錯誤（誤將?exp3、exp4、exp5?都當作獨立參數）。
D. 5：錯誤（誤將?exp1?到?exp5?都當作獨立參數）。

4. 關鍵點

逗號運算符會將多個表達式合并為一個表達式，最終只返回最后一個表達式的值。
函數調用的實參個數取決于最外層的逗號分隔，這里只有?(exp1,exp2)?和?(exp3,exp4,exp5)?兩部分。

正確答案????????B. 2

😀 第28題

語句int(*ptr)()的含義是（）。

A. ptr是?個返回值是int的函數

B. ptr是指向int型數據的指針變量

C. ptr是指向函數的指針，該函數返回?個int型數據

D. ptr是?個函數名，該函數的返回值是指向int型數據的指針

?解題步驟

1. 理解?int (*ptr)();?的語法

int (*ptr)();?是一個函數指針的聲明。
分解語法：
- *ptr：ptr?是一個指針。
- (*ptr)()：ptr?指向一個函數（括號表示函數調用）。
- int (*ptr)();：ptr?指向的函數返回?int?類型。

2. 排除錯誤選項

A.?ptr?是一個返回值是?int?的函數
- 錯誤。ptr?是指針，不是函數本身。
B.?ptr?是指向?int?型數據的指針變量
- 錯誤。ptr?指向函數，而非?int?數據。
D.?ptr?是一個函數名，該函數的返回值是指向?int?型數據的指針
- 錯誤。ptr?是指針，不是函數名；且它指向的函數返回?int，而非?int*。

3. 正確選項

C.?ptr?是指向函數的指針，該函數返回一個?int?型數據
- 正確。ptr?是函數指針，指向的函數返回?int。

4. 關鍵點

int (*ptr)();?是函數指針的經典聲明。
對比?int *ptr();（返回?int*?的函數聲明），注意括號的位置差異。

正確答案????????C.?ptr?是指向函數的指針，該函數返回一個?int?型數據

😀第29題

以下不正確的定義語句是（）。

A. double x[5]={1.0,2.0,3.0,4.0,5.0}; ????????B. int y[5]={0,1,2,3,4,5};

C. char c1[]={'1', '2', '3', '4', '5'}; ????????D. char c2[]={'a', 'b', 'c'};

解題步驟

1. 理解數組定義和初始化的規則

在C語言中，數組的定義和初始化需遵循以下規則：

數組大小可以顯式指定（如?int a[5]），或通過初始化列表隱式確定（如?int a[] = {1, 2}）。
初始化的元素數量不能超過數組大小。例如?int a[2] = {1, 2, 3};?是錯誤的。
如果初始化列表的元素少于數組大小，剩余元素默認初始化為?0（或?'\0'?對于字符數組）。

2. 逐項分析選項

A.?double x[5] = {1.0, 2.0, 3.0, 4.0, 5.0};
- 正確。數組大小為?5，初始化列表恰好有?5?個?double?值。
B.?int y[5] = {0, 1, 2, 3, 4, 5};
- 不正確。數組?y?的大小為?5，但初始化列表有?6?個元素（0, 1, 2, 3, 4, 5），超出數組容量。
C.?char c1[] = {'1', '2', '3', '4', '5'};
- 正確。數組大小未顯式指定，根據初始化列表隱式確定為?5。
D.?char c2[] = {'a', 'b', 'c'};
- 正確。數組大小隱式確定為?3。

3. 關鍵點

選項B是唯一違反數組初始化規則的語句（初始化元素數量 > 數組大小）。
其他選項均符合語法規則。

4. 常見陷阱

注意隱式確定數組大小時，初始化列表的元素數量必須與數組大小匹配（如選項B顯式指定了大小?[5]，但給了?6?個值）。
字符數組的初始化可以用字符列表（如選項C、D），但需注意是否包含字符串終止符?'\0'（本題不涉及此問題）。

正確答案????????B.?int y[5] = {0, 1, 2, 3, 4, 5};

😀 第30題

若有以下定義，則對數組元素的正確引用是（）。

int a[5],*p=a;

A. *&a[5] ????????B. (*a)+2 ????????C. *p+4 ????????D. *(a+2)

解題步驟

1. 理解數組和指針的定義

int a[5]：定義一個包含 5 個整數的數組?a，元素為?a[0]?到?a[4]。
int *p = a：定義指針?p?并指向數組?a?的首地址（即?&a[0]）。

2. 數組元素的引用方式

數組元素可以通過以下方式引用：

下標法：a[i]（i?從?0?到?4）。
指針法：
- *(a + i)：等價于?a[i]。
- *(p + i)：等價于?p[i]。

3. 逐項分析選項

A.?*&a[5]
- a[5]：越界訪問（數組下標范圍為?0?到?4）。
- &a[5]?是合法的地址（指向?a[4]?的下一個位置），但解引用?*&a[5]?是未定義行為。
- 錯誤。
B.?(*a)+2
- *a?等價于?a[0]（數組首元素的值）。
- (*a)+2?是?a[0] + 2，不是對數組元素的引用，而是對值的運算。
- 錯誤。
C.?*p+4
- *p?等價于?a[0]（p?指向?a[0]）。
- *p+4?是?a[0] + 4，不是對數組元素的引用，而是對值的運算。
- 錯誤。
D.?*(a+2)
- a+2?是?&a[2]（第 3 個元素的地址）。
- *(a+2)?等價于?a[2]，是對數組元素的正確引用。
- 正確。

4. 關鍵點

數組元素的引用必須直接或間接指向某個元素（如?a[i]?或?*(a+i)）。
選項 B 和 C 是對元素值的運算，而非引用元素本身。
選項 A 是越界訪問。

5. 排除法

A 越界，B 和 C 是運算，只有 D 是合法的元素引用。

正確答案????????D.?*(a+2)

😀 第31題

下列字符數組初始化語句中，不正確的是（）。

A. char c[]='goodmorning';

B. char c[20]= "goodmorning";

C. char c[]={'a','b','c','d'};

D. char c[]={"goodmorning"};

解題步驟

1. 理解字符數組的初始化規則

在C語言中，字符數組可以通過以下方式初始化：

用字符串字面量初始化：
- 語法：char c[] = "string";?或?char c[N] = "string";。
- 字符串字面量會自動在末尾添加?'\0'（空字符）。
用字符列表初始化：
- 語法：char c[] = {'a', 'b', 'c'};。
- 不會自動添加?'\0'，除非顯式包含（如?{'a', 'b', '\0'}）。

2. 逐項分析選項

A.?char c[] = 'goodmorning';
- 錯誤：
  - 單引號?''?用于表示單個字符（如?'g'），不能包裹多個字符。
  - 正確寫法應為雙引號?""：char c[] = "goodmorning";。
B.?char c[20] = "goodmorning";
- 正確：
  - 數組大小為?20，字符串?"goodmorning"（長度?10?+?'\0'）可以完全存入，剩余元素自動填充?'\0'。
C.?char c[] = {'a', 'b', 'c', 'd'};
- 正確：
  - 隱式確定數組大小為?4，初始化為字符列表（無?'\0'）。
D.?char c[] = {"goodmorning"};
- 正確：
  - 等價于?char c[] = "goodmorning";，花括號?{}?可省略。

3. 關鍵點

選項A的錯誤在于混淆了字符常量（單引號）和字符串字面量（雙引號）。
其他選項均符合字符數組初始化的語法規則。

4. 常見陷阱

單引號?''?只能用于單個字符（如?'a'），多字符會觸發編譯器警告或錯誤。
雙引號?""?用于字符串，會自動添加?'\0'。

正確答案????????A.?char c[] = 'goodmorning';

😀 第32題

下列程序的運行結果為（）。

#include<stdio.h>void abc(char *str) {int a, b, i, j;for (i = j = 0; str[i] != '\0'; i++) {if (str[i] != 'a') {str[j++] = str[i];}}str[j] = '\0';
}void main() {char str[] = "abcdef";abc(str);printf("str[]=%s", str);
}

A. str[]=bcdef ????????B. str[]=abcdef ????????C. str[]=a ????????D. str[]=ab

解題步驟

1. 理解函數?abc?的功能

函數?abc(char *str)?的作用是過濾字符串中的字符 'a'，具體邏輯如下：

初始化兩個指針?i?和?j（均從?0?開始）。
遍歷字符串?str（直到遇到?'\0'）：
- 如果當前字符?str[i]?不是?'a'，則將其復制到?str[j]?并遞增?j。
- 如果當前字符是?'a'，則跳過（不復制）。
最后在?str[j]?處添加字符串結束符?'\0'。

2. 分析字符串處理過程

初始字符串："abcdef"（即?{'a', 'b', 'c', 'd', 'e', 'f', '\0'}）。

遍歷過程：
- i=0：str[0]='a'?→ 跳過，j=0。
- i=1：str[1]='b'?→ 復制到?str[0]，j=1。
- i=2：str[2]='c'?→ 復制到?str[1]，j=2。
- i=3：str[3]='d'?→ 復制到?str[2]，j=3。
- i=4：str[4]='e'?→ 復制到?str[3]，j=4。
- i=5：str[5]='f'?→ 復制到?str[4]，j=5。
- i=6：str[6]='\0'?→ 循環結束。
結果字符串：
- 復制后的字符序列：{'b', 'c', 'd', 'e', 'f', '\0'}。
- 最終?str?的內容為?"bcdef"。

3. 輸出結果

printf?輸出?str[]=bcdef。

4. 驗證選項

A.?str[]=bcdef：正確。
B.?str[]=abcdef：錯誤（未過濾?'a'）。
C.?str[]=a：錯誤（邏輯完全不符）。
D.?str[]=ab：錯誤（未體現過濾過程）。

5. 關鍵點

函數?abc?的核心邏輯是原地刪除字符 'a'，其他字符前移。
j?始終指向新字符串的當前位置，i?遍歷原字符串。

正確答案????????A.?str[]=bcdef

😀 第33題

閱讀下面程序，程序執行后的結果為（）。

#include "stdio.h"
int main() {char *str = "abcdefghijklmnopq";while (*str++ != 'e');printf("%c\n", *str);
}

A. f ????????B. a ????????C. e ????????D. q

解題步驟

1. 理解指針和字符串

char *str = "abcdefghijklmnopq";：str?是一個指針，指向字符串常量?"abcdefghijklmnopq"?的首字符?'a'。
字符串在內存中的布局：'a',?'b',?'c',?'d',?'e',?'f', ...,?'q',?'\0'。

2. 分析?while?循環

while (*str++ != 'e');?的執行過程：
1. *str++?的運算順序：
  - 先取?*str?的值（當前字符），再執行?str++（指針后移）。
2. 循環終止條件：
  - 當?*str?為?'e'?時，str?已經指向?'e'?的下一個字符?'f'（因為?str++?已執行）。
3. 具體步驟：
  - 初始：str?指向?'a'，比較?'a' != 'e'?→?str?指向?'b'。
  - 比較?'b' != 'e'?→?str?指向?'c'。
  - 比較?'c' != 'e'?→?str?指向?'d'。
  - 比較?'d' != 'e'?→?str?指向?'e'。
  - 比較?'e' != 'e'（不成立），循環結束，此時?str?指向?'f'（因為?str++?已執行）。

3.?printf?的輸出

循環結束后，str?指向?'f'，因此?printf("%c\n", *str);?輸出?'f'。

4. 驗證選項

A.?f：正確。
B.?a：錯誤（初始字符，但指針已移動）。
C.?e：錯誤（str?已跳過?'e'）。
D.?q：錯誤（指針未遍歷到末尾）。

5. 關鍵點

*str++?是先取值后自增，因此循環結束時?str?指向目標字符?'e'?的下一個字符?'f'。
如果寫成?while (*++str != 'e');，則?str?會指向?'e'?本身。

正確答案????????A.?f

😀 第34題

設有如下的程序段：

char str[]="HelloWorld";char*ptr;ptr=str;

執行上面的程序段后， *(ptr+10)的值為（）。

A. '\0' ????????B. '0' ????????C. 不確定的值 ????????D. '0'的地址

解題步驟

1. 理解字符串和指針的初始化

char str[] = "HelloWorld";：
- 定義并初始化一個字符數組?str，內容為?"HelloWorld"。
- 字符串字面量?"HelloWorld"?在內存中的布局：'H',?'e',?'l',?'l',?'o',?'W',?'o',?'r',?'l',?'d',?'\0'。
- 因此，str?的大小為?11（10個字符 + 1個終止符?'\0'）。
char *ptr; ptr = str;：
- 定義指針?ptr?并指向?str?的首地址（即?&str[0]）。

2. 計算?*(ptr+10)?的值

ptr?指向?str[0]，ptr+10?指向?str[10]。
str[10]?是字符串的第?11?個元素（下標從?0?開始），即字符串的終止符?'\0'。
因此，*(ptr+10)?的值為?'\0'。

3. 驗證選項

A.?'\0'：正確（字符串的終止符）。
B.?'0'：錯誤（字符?'0'?的ASCII碼為?48，與?'\0'?不同）。
C. 不確定的值：錯誤（字符串明確以?'\0'?結尾）。
D.?'0'的地址：錯誤（*(ptr+10)?是值，不是地址）。

4. 關鍵點

字符串字面量?"HelloWorld"?隱式包含終止符?'\0'，因此?str[10]?是?'\0'。
*(ptr+10)?等價于?ptr[10]?或?str[10]。

正確答案????????A.?'\0'

😀 第35題

下述語句中，在字符串s1和s2相等時顯示"they are Equal"的是（）。

A. if(*s1==*s2) puts("they are Equal");

B. if(!strcmp(s1,s2)) puts("they are Equal");

C. if(s1==s2) Puts("they are Equal");

D. if(strcmp(s1,s2)) puts("they are Equal");

解題步驟

1. 理解字符串比較的規則

在C語言中：

字符串內容比較需要使用?strcmp(s1, s2)?函數：
- 若?s1?和?s2?內容相同，strcmp?返回?0。
- 若?s1?字典序大于?s2，返回正整數。
- 若?s1?字典序小于?s2，返回負整數。
直接比較指針（如?s1==s2）：僅比較地址是否相同，而非內容。

2. 逐項分析選項

A.?if(*s1==*s2) puts("they are Equal");
- 錯誤：*s1?和?*s2?是比較兩個字符串的首字符，而非整個字符串。
B.?if(!strcmp(s1,s2)) puts("they are Equal");
- 正確：strcmp(s1,s2)==0?時表示字符串相等，!0?為真，觸發輸出。
C.?if(s1==s2) puts("they are Equal");
- 錯誤：比較的是指針地址，即使內容相同，若地址不同（如不同數組），結果也為假。
D.?if(strcmp(s1,s2)) puts("they are Equal");
- 錯誤：strcmp?返回?0?時表示相等，但?if(0)?為假，邏輯反了。

3. 關鍵點

strcmp?的返回值：相等時返回?0，因此條件應為?!strcmp(s1,s2)?或?strcmp(s1,s2)==0。
選項B是唯一正確判斷字符串內容相等的寫法。

4. 常見陷阱

直接比較指針（選項C）是新手常見錯誤。
混淆?strcmp?的返回值邏輯（選項D）。

正確答案????????B.?if(!strcmp(s1,s2)) puts("they are Equal");

😀 第36題

在?個C源程序文件中，定義一個只允許本源文件中所有函數使用的全局變量的存儲類別是

（）。

A. extern ????????B. static ????????C. register???????? D. auto

解題步驟

1. 理解題目要求

題目要求定義一個全局變量，但其作用范圍僅限于當前源文件（即其他源文件無法訪問）。這種變量需要具有文件作用域和內部鏈接性。

2. 分析存儲類別的特性

A.?extern：
- 用于聲明在其他文件中定義的全局變量（擴展作用域）。
- 不限制變量的鏈接性，無法實現“僅當前文件使用”。
- 不符合要求。
B.?static：
- 當用于全局變量時，將其鏈接性限制為內部鏈接（僅當前文件可見）。
- 其他文件即使使用?extern?也無法訪問該變量。
- 完全符合要求。
C.?register：
- 建議編譯器將變量存儲在寄存器中（僅用于局部變量，不改變作用域或鏈接性）。
- 不適用。
D.?auto：
- 默認的局部變量存儲類別（自動存儲期），不能用于全局變量。
- 不適用。

3. 關鍵點

static?修飾全局變量：
將變量的作用域限制在當前文件內，實現“文件私有”全局變量。
其他選項或無法限制作用域（extern），或根本不適用（register、auto）。

4. 示例代碼

// file1.c
static int fileLocalVar = 42; // 僅當前文件可見void func1() {fileLocalVar++; // 可訪問
}// file2.c
extern int fileLocalVar; // 錯誤！無法訪問其他文件的 static 全局變量

正確答案????????B.?static

😀 第37題

以下程序的輸出結果是（）。

#include <stdio.h>void prt(int *x, int *y, int *z) {printf("%d,%d,%d\n", ++*x, ++*y, *(z++));
}int main() {int a = 10, b = 40, c = 20;prt(&a, &b, &c);prt(&a, &b, &c);
}

A. 11,42,31 12,22,41 ????????B. 11,41,20 12,42,20

C. 11,21,40 11,21,21 ????????D. 11,41,21 12,42,22

解題步驟

1. 理解函數?prt?的行為

函數?prt?接收三個指針參數?x、y、z，并在?printf?中執行以下操作：

++*x：對?*x（即?a）先自增，再取值。
++*y：對?*y（即?b）先自增，再取值。
*(z++)：先取?*z（即?c）的值，再對指針?z?自增（不影響?c?的值）。

2. 第一次調用?prt(&a, &b, &c)

初始值：a=10,?b=40,?c=20。
++*x：a?自增為?11，取值?11。
++*y：b?自增為?41，取值?41。
*(z++)：取?*z（c=20），然后?z?指針自增（不影響?c）。
輸出：11,41,20。
此時變量值：a=11,?b=41,?c=20。

3. 第二次調用?prt(&a, &b, &c)

當前值：a=11,?b=41,?c=20。
++*x：a?自增為?12，取值?12。
++*y：b?自增為?42，取值?42。
*(z++)：取?*z（c=20），然后?z?指針自增（不影響?c）。
輸出：12,42,20。
此時變量值：a=12,?b=42,?c=20。

4. 關鍵點

*(z++)?是先取值后指針自增，因此兩次調用均輸出?c?的原始值?20。
++*x?和?++*y?直接修改了?a?和?b?的值，因此第二次調用時的值會遞增。

5. 驗證選項

B：11,41,20 12,42,20?與我們的分析完全一致。
其他選項：
- A：c?的值錯誤（應為?20）。
- C：b?的值錯誤（應為?41,42）。
- D：c?的值錯誤（應為?20）。

正確答案????????B.?11,41,20 12,42,20

😀 第38題

設有以下說明，則不正確的敘述是（）。

union un{int a;char b;float c;}arr;

A. arr所占的內存長度等于成員c的長度 ????????B. arr的地址和它的各成員的地址都是同?地址

C. arr可以作為函數參數 ????????D. 不能在定義arr時對它初始化

解題步驟

1. 理解聯合體（union）的特性

聯合體?union?的所有成員共享同一塊內存空間，其大小為最大成員的大小。具體特性：

內存共享：所有成員的地址相同（即聯合體的地址）。
內存大小：由最大成員決定（如?int、float?通常為 4 字節，char?為 1 字節）。
初始化：可以在定義時初始化，但只能初始化第一個成員。
函數參數：聯合體可以作為函數參數傳遞。

2. 逐項分析選項

A.?arr?所占的內存長度等于成員?c?的長度
- 正確。聯合體的大小由最大成員決定（假設?float c?是最大成員，通常為 4 字節）。
B.?arr?的地址和它的各成員的地址都是同一地址
- 正確。聯合體的所有成員共享同一內存地址。
C.?arr?可以作為函數參數
- 正確。聯合體可以像普通變量一樣作為函數參數傳遞。
D. 不能在定義?arr?時對它初始化
- 不正確。聯合體可以在定義時初始化，但只能初始化第一個成員。例如：
  
  union un arr = {10}; // 初始化第一個成員 a

3. 關鍵點

選項D的表述過于絕對。聯合體可以在定義時初始化（只是限制較多）。
其他選項均符合聯合體的特性。

4. 常見誤區

聯合體的初始化只能針對第一個成員，但題目未明確說明初始化內容，因此“不能初始化”是錯誤的。

正確答案????????D. 不能在定義?arr?時對它初始化

🤞 第39題

若x=4，y=5，則x&y的結果是（）。

A. 0 ????????B. 4 ????????C. 3 ????????D. 5

解題步驟

1. 理解按位與運算（&）

按位與運算的規則是對兩個數的二進制表示逐位進行邏輯與操作：

1 & 1 = 1
1 & 0 = 0
0 & 1 = 0
0 & 0 = 0

2. 將?x?和?y?轉換為二進制

x = 4?的二進制表示：0100
y = 5?的二進制表示：0101

3. 逐位計算?x & y

? 0100 (4)
& 0101 (5)
? ----
? 0100 (4)

從右到左逐位計算：
- 第0位：0 & 1 = 0
- 第1位：0 & 0 = 0
- 第2位：1 & 1 = 1
- 第3位：0 & 0 = 0
結果：0100（十進制?4）。

4. 驗證選項

A. 0：錯誤。
B. 4：正確。
C. 3：錯誤（0100 & 0101?不可能得到?0011）。
D. 5：錯誤。

5. 關鍵點

按位與運算的結果是逐位比較后的二進制值，不是簡單的數學加減。
4 & 5?的二進制結果為?0100（即十進制?4）。

正確答案????????B. 4

🤞 第40題

下列關于C語言數據文件的敘述中正確的是（）。

A. 文件由ASCII碼字符序列組成，C語言只能讀寫文本文件

B. 文件由二進制數據序列組成，C語言只能讀寫二進制文件

C. 文件件由記錄序列組成，可按數據的存放形式分為二進制文件和文本文件

D. 文件由數據流形式組成，可按數據的存放形式分為二進制文件和文本文件

解題步驟

1. 理解C語言中文件的基本概念

在C語言中，文件被看作是一個數據流（stream），可以是：

文本文件：由可讀的ASCII字符組成，每行以換行符結束。
二進制文件：由二進制數據直接存儲，無格式轉換。

2. 分析選項

A. 文件由ASCII碼字符序列組成，C語言只能讀寫文本文件
- 錯誤：C語言可以處理二進制文件（如?fopen?使用?"rb"?模式），且文件內容不限于ASCII字符。
B. 文件由二進制數據序列組成，C語言只能讀寫二進制文件
- 錯誤：C語言也能讀寫文本文件（如?"r"?模式），且文本文件本質也是二進制存儲（但內容可讀）。
C. 文件由記錄序列組成，可按數據的存放形式分為二進制文件和文本文件
- 部分錯誤：
  - “記錄序列”是特定數據結構的描述（如數據庫），不適用于普通文件。
  - 文件分類正確，但前提描述不準確。
D. 文件由數據流形式組成，可按數據的存放形式分為二進制文件和文本文件
- 正確：
  - C語言將文件視為數據流（stream），分類為文本/二進制文件。
  - 文本文件：字符流；二進制文件：原始字節流。

3. 關鍵點

數據流（stream）是C語言對文件的抽象，與具體存儲形式無關。
文本文件和二進制文件的區別在于數據解釋方式，而非物理存儲。

4. 排除法

A、B 過于片面（忽略另一種文件類型）。
C 的“記錄序列”不準確。
D 的描述完全符合C語言標準。

正確答案????????D. 文件由數據流形式組成，可按數據的存放形式分為二進制文件和文本文件

🤞 第41題

給定程序中，函數fun的功能是用函數指針指向要調用的函數，并進行調用。規定在__2__處使fa指向函數f1，在__3__處使fb指向函數f2。當調用正確時，程序輸出：

x1=5.000000，x2=3.000000，x1*x1+x1*x2=40.000000

請在程序的下劃線處填入正確的內容并把下劃線刪除，使程序得出正確的結果。

注意：源程序存放在考生文件夾下的BLANK.C中。

不得增行或刪行，也不得更改程序的結構！

給定源程序：

🤞 1. 正確答案： double ????????2. 正確答案： f1 ????????3. 正確答案： f2

在給定的代碼中，r1?和?r2?對函數指針?f?的使用方式不同：

r1 = f(a);?直接調用?f。
r2 = (*f)(a, b);?通過?*f?調用?f。

原因解釋

函數指針的兩種調用方式：
- C語言中，函數指針可以通過兩種方式調用：
  - 直接調用：f(a)，編譯器會自動解引用。
  - 顯式解引用：(*f)(a, b)，通過?*?顯式解引用函數指針。
- 兩種方式在功能上是等價的，只是語法不同。
代碼中的不一致性：
- 在?r1 = f(a);?中，直接使用?f?調用?f1（編譯器隱式處理）。
- 在?r2 = (*f)(a, b);?中，顯式使用?*f?調用?f2，可能是為了強調?f?是一個指針。
歷史習慣與代碼風格：
- 早期C代碼中，顯式解引用（(*f)()）更常見，用于明確表示?f?是指針。
- 現代C標準允許直接調用（f()），因為函數名本身也會被轉換為函數指針。
實際效果：
- 無論是否使用?*，函數調用的結果完全相同。
- 例如：
  - f(a)?和?(*f)(a)?是等價的。
  - f(a, b)?和?(*f)(a, b)?也是等價的。