前言

??辛苦搬磚 「十年」 的老碼農，「四年」 的 C/C++ 面試官經驗，整理出了一些當年用來「虐候選人」的題（不要打我🤣🤣🤣），先弄個 「 200 」 題吧，還有 「 8800 」 題，后面有時間再搞吧，
??由于題目較多，整理的也比較倉促，如果發現哪道題目有誤，可以在 「評論區指出」 ，我們一起完善這套試題，然后，去 「虐更多的人」 ？！啊？？？
??題目均為「四選項選擇題」，用 「滑鼠/手指」 「反選」 對應題目中的 「括號」 就能看到答案了，

文章目錄

前言
第一題 - 遞回
第二題 - 運算子
第三題 - 字串
第四題 - 智能指標
第五題 - 解構式
第六題 - 指標
第七題 - 溢位
第八題 - 字串
第九題 - 函式
第十題 - 靜態變數
第十一題 - 函式指標
第十二題 - 三級指標
第十三題 - 強制轉換
第十四題 - 靜態變數
第十五題 - 編譯
第十六題 - 指標
第十七題 - 輸入
第十八題 - 設計模式
第十九題 - 變數
第二十題 - 進制轉換
第二十一題 - 賦值運算子
第二十二題 - 變數
第二十三題 - 全域變數
第二十四題 - 函式
第二十五題 - 整型
第二十六題 - 整型
第二十七題 - 靜態變數
第二十八題 - 運算子
第二十九題 - 運算子
第三十題 - 型別轉換
第三十一題 - 逗號運算式
第三十二題 - 位元組序
第三十三題 - 指標
第三十四題 - 補碼
第三十五題 - 類
第三十六題 - 進制轉換
第三十七題 - 位與運算
第三十八題 - 位或運算
第三十九題 - 異或運算
第四十題 - 按位取反運算
第四十一題 - 左移位運算
第四十二題 - 右移位運算
第四十三題 - 右移位運算
第四十四題 - 虛函式
第四十五題 - 建構式
第四十六題 - 記憶體泄漏
第四十七題 - 常量
第四十八題 - 建構式
第四十九題 - 回圈
第五十題 - 回圈
第五十一題 - 回圈
第五十二題 - 回圈
第五十三題 - 常量
第五十四題 - 參考
第五十五題 - 建構式
第五十六題 - 智能指標
第五十七題 - 記憶體分配
第五十八題 - 記憶體分配
第五十九題 - C++性質
第六十題 - 位與運算
第六十一題 - 位與運算
第六十二題 - 指標和參考
第六十三題 - 例外
第六十四題 - 靜態變數
第六十五題 - 編譯
第六十六題 - 指標
第六十七題 - 輸入
第六十八題 - 設計模式
第六十九題 - 變數
第七十題 - 進制轉換
第七十一題 - 賦值運算子
第七十二題 - 變數
第七十三題 - 全域變數
第七十四題 - 函式宣告
第七十五題 - 進制
第七十六題 - 進制
第七十七題 - 靜態變數
第七十八題 - 運算子優先級
第七十九題 - 運算子優先級
第八十題 - 型別轉換
第八十一題 - 逗號運算式
第八十二題 - 位元組序
第八十三題 - 指標
第八十四題 - 補碼
第八十五題 - 類
第八十六題 - 進制轉換
第八十七題 - 位與運算
第八十八題 - 位或運算
第八十九題 - 異或運算
第九十題 - 按位取反運算
第九十一題 - 左移位運算
第九十二題 - 右移位運算
第九十三題 - 右移位運算
第九十四題 - 虛函式
第九十五題 - 建構式
第九十六題 - 記憶體泄漏
第九十七題 - 常量
第九十八題 - 建構式
第九十九題 - 回圈
第一百題 - 回圈
第一百零一題 - 遞回
第一百零二題 - 運算子
第一百零三題 - 字串
第一百零四題 - 智能指標
第一百零五題 - 解構式
第一百零六題 - 指標
第一百零七題 - 溢位
第一百零八題 - 字串
第一百零九題 - 變數
第一百十題 - 進制轉換
第一百十一題 - 賦值運算子
第一百十二題 - 變數
第一百十三題 - 全域變數
第一百十四題 - 函式
第一百十五題 - 整型
第一百十六題 - 整型
第一百十七題 - 靜態變數
第一百十八題 - 運算子
第一百十九題 - 運算子
第一百二十題 - 型別轉換
第一百二十一題 - 逗號運算式
第一百二十二題 - 邏輯運算子
第一百二十三題 - 算術運算子
第一百二十四題 - 虛函式
第一百二十五題 - 建構式
第一百二十六題 - 記憶體泄漏
第一百二十七題 - 常量
第一百二十八題 - 建構式
第一百二十九題 - 回圈
第一百三十題 - 進制轉換
第一百三十一題 - 回圈
第一百三十二題 - 回圈
第一百三十三題 - 常量
第一百三十四題 - 參考
第一百三十五題 - 建構式
第一百三十六題 - 智能指標
第一百三十七題 - 記憶體分配
第一百三十八題 - 建構式
第一百三十九題 - sizeof
第一百四十題 - 模板
第一百四十一題 - 記憶體
第一百四十二題 - 編譯原理
第一百四十三題 - 編譯原理
第一百四十四題 - 記憶體管理
第一百四十五題 - 記憶體管理
第一百四十六題 - 排序
第一百四十七題 - 常量
第一百四十八題 - 排序
第一百四十九題 - 回圈
第一百五十題 - 回圈
第一百五十一題 - 回圈
第一百五十二題 - 回圈
第一百五十三題 - 常量
第一百五十四題 - 參考
第一百五十五題 - 建構式
第一百五十六題 - 記憶體分配
第一百五十七題 - 記憶體分配
第一百五十八題 - 記憶體分配
第一百五十九題 - 編譯原理
第一百六十題 - 位與運算
第一百六十一題 - 位與運算
第一百六十二題 - 指標和參考
第一百六十三題 - 算術運算子
第一百六十四題 - 靜態變數
第一百六十五題 - extern關鍵字
第一百六十六題 - static關鍵字
第一百六十七題 - volatile關鍵字
第一百六十八題 - const關鍵字
第一百六十九題 - 參考
第一百七十題 - 多型
第一百七十一題 - 動態系結
第一百七十二題 - 變數
第一百七十三題 - 全域變數
第一百七十四題 - 智能指標
第一百七十五題 - 行內函式
第一百七十六題 - 初始化串列
第一百七十七題 - 庫函式
第一百七十八題 - 賦值運算子
第一百七十九題 - 運算子
第一百八十題 - 型別轉換
第一百八十一題 - 逗號運算式
第一百八十二題 - 位元組序
第一百八十三題 - 指標
第一百八十四題 - 補碼
第一百八十五題 - 虛函式
第一百八十六題 - 排序
第一百八十七題 - 位與運算
第一百八十八題 - 位或運算
第一百八十九題 - 異或運算
第一百九十題 - 按位取反運算
第一百九十一題 - this
第一百九十二題 - 拷貝構造
第一百九十三題 - 拷貝構造
第一百九十四題 - 虛函式
第一百九十五題 - 建構式
第一百九十六題 - 記憶體泄漏
第一百九十七題 - 常量
第一百九十八題 - 函式多載
第一百九十九題 - 回圈
第兩百題 - 回圈

🙉飯不食，水不飲，題必須刷🙉
C語言免費動漫教程，和我一起打卡！ 🌞《光天化日學C語言》🌞
LeetCode 太難？先看簡單題！ 🧡《C語言入門100例》🧡
資料結構難？不存在的！ 🌳《資料結構入門》🌳
LeetCode 太簡單？演算法學起來！ 🌌《夜深人靜寫演算法》🌌
究極演算法奧義！深度學習！ 🟣《深度學習100例》🟣

第一題 - 遞回

1、對于以下遞回函式 f f f，呼叫 f ( 5 ) f(5) f(5)，其回傳值為 ( ( ( A ) ) ) ，

int f(int n) {
    if (n)
        return f(n - 1) + n;
    return n;
}

15
10
5
以上均不是

第二題 - 運算子

2、以下哪個運算子不能多載 ( ( ( C ) ) ) ，

=
>
sizeof
%

第三題 - 字串

3、程式char c[5]={'a','b','\0','c','\0'}; printf("%s",c);的運行結果是 ( ( ( D ) ) ) ，

‘a’ ‘b’
ab\0c\0
ab c
ab

第四題 - 智能指標

4、下面關于 shared_ptr 說法錯誤的有 ? ( ( ( C ) ) ) ，

一個 shared_ptr 物件物體可被多個執行緒同時讀取
兩個 shared_ptr 物件物體可以被兩個執行緒同時寫入
多執行緒讀寫同一個 shared_ptr 物件不需要加鎖,因為shared_ptr 物件本身是執行緒安全的
使用 shared_ptr 時候最好使用 make_shared 來分配記憶體

第五題 - 解構式

5、對于任意一個類，解構式的個數最多為 ( ( ( B ) ) ) ，

第六題 - 指標

6、 64位系統下，*p = NULL和*p = new char[100]， sizeof(p)各為多少？ ( ( ( D ) ) ) ，

第七題 - 溢位

7、執行 C++ 程式時出現的 “溢位” 錯誤屬于 ( ( ( D ) ) ) 錯誤，

編譯
鏈接
邏輯
運行

第八題 - 字串

8、字串"A+K=47\n"的長度為 ( ( ( B ) ) ) ，

第九題 - 函式

9、在下列關于 C++ 函式的敘述中，正確的是 ( ( ( C ) ) ) ，

每個函式至少需要一個引數
每個函式都必須有回傳值
函式在被呼叫之前必須先宣告
函式不能自己呼叫自己

第十題 - 靜態變數

10、 static 型別的變數，默認的初始化值是？ ( ( ( A ) ) ) ，

0
空格
隨機變數
1

第十一題 - 函式指標

11、 對于如下的這段程式，以下不合法的是 ( ( ( C ) ) ) ，

int f1(float);
int f2(char);
int f3(float);
int f4(float);
int (*pf)(float);

int (*p) (float) = &f1;
pf = &f4;
pf = &f2;
pf = f3;

第十二題 - 三級指標

12、 下述程式的輸出是 ( ( ( A ) ) ) ，

#include<stdio.h>
 
int main() {
    static char *s[] = {"black", "white", "pink", "violet"};
    char **ptr[] = {s+3, s+2, s+1, s}, ***p;
    p = ptr;
    ++p;
    printf("%s", **p+1);
    return 0;
}

ink
pink
white
violet

第十三題 - 強制轉換

13、 int a = 8, b = 5, c;, 執行陳述句 c = a / b + 0.5;后, c的值為 ( ( ( C ) ) ) ，

第十四題 - 靜態變數

14、 在C語言中，關于靜態變數的說法，正確的是 ( ( ( C ) ) ) ，

靜態全域變數作用域為一個程式的所有源檔案
靜態變數和常量相同
函式中的靜態變數，在函式退出后不被釋放
靜態變數只可以賦值一次

第十五題 - 編譯

15、 一個 C++ 專案中有 3 個 .h 檔案，5 個 .cpp 檔案，編譯之后生成的 .obj 檔案的數量是 ( ( ( B ) ) ) ，

3
5
8
不一定

第十六題 - 指標

16、 設有如下的程式段 char *ptr = NULL; char str[] = "hehe"; ptr = str;，執行完上面的程式段后，*(ptr+4)的值為 ( ( ( B ) ) ) ，

‘e’
‘\0’
不確定的值
‘e’ 的地址

第十七題 - 輸入

17、 有如下陳述句序列：char str[10]; cin>>str;
當從鍵盤輸入I love this blog時，str中的字串是 ( ( ( D ) ) ) ，

I love this blog
I love thi
I love
I

第十八題 - 設計模式

18、 在結構化的程式設計中，模塊劃分的原則是 ( ( ( D ) ) ) ，

模塊間的聯系越緊密越好
模塊功能越多越好
模塊越大越好
模塊內具有高內聚，模塊間具有低耦合

第十九題 - 變數

19、 下面的型別宣告中正確是 ( ( ( D ) ) ) ，

int &a[4];
int &=b
int &&c
int d, *e = &d

第二十題 - 進制轉換

20、 以下哪個式子有可能在某個進制下成立 ( ( ( A ) ) ) ，

13 * 14 = 204
12 * 34 = 568
14 * 14 = 140
1 + 1 = 109

第二十一題 - 賦值運算子

21、 x = 6; x += x -= x*x;執行完畢以后，x的值為 ( ( ( B ) ) ) ，

第二十二題 - 變數

22、 char 型別值的數值范圍為 ( ( ( C ) ) ) ，

0 ~ 32767
0 ~ 65535
-128 ~ 127
0 ~ 256

第二十三題 - 全域變數

23、 關于全域變數，下列說法正確的是 ( ( ( A ) ) ) ，

全域變數可用于函式之間傳遞資料
任何全域變數都只能被定義它的函式中的陳述句訪問
任何全域變數都只能被定義它的程式檔案中的函式訪問
任何全域變數都可以被應用系統匯總任何程式檔案中的任何函式訪問

第二十四題 - 函式

24、 如果函式不需要任何回傳值，使用什么形式的函式宣告？ ( ( ( B ) ) ) ，

func()
void func()
func(void)
int func()

第二十五題 - 整型

25、 哪個表示的是十六進制？ ( ( ( B ) ) ) ，

01234
0x1234
0b0001
16

第二十六題 - 整型

26、 哪個表示的是八進制？ ( ( ( A ) ) ) ，

01234
0x1234
0b0001
008

第二十七題 - 靜態變數

27、 靜態區域變數存盤在行程的 ( ( ( D ) ) ) ，

堆疊區
暫存器區
代碼區
全域區

第二十八題 - 運算子

28、 已知x = 43，ch = 'A', y=0;則運算式(ch < 'B' && !y && x - 43)的值是 ( ( ( A ) ) ) ，

0
1
語法錯誤
“真”

第二十九題 - 運算子

29、 已知x = 43，ch = 'A', y=0;則運算式(ch < 'B' || !y && x - 43)的值是 ( ( ( B ) ) ) ，

0
1
語法錯誤
“真”

第三十題 - 型別轉換

30、 char w; int x; float y; double z;則運算式: w * x - z + y值的資料型別是 ( ( ( B ) ) ) ，

float
double
int
char

第三十一題 - 逗號運算式

31、 函式呼叫陳述句func(rec1,rec2+rec3,(rec4,rec5));中的實參的個數是 ( ( ( A ) ) ) ，

第三十二題 - 位元組序

32、 X 定義如下，若存在 X a; a.x=0x11223344;則 a.y[1]的值可能為 ( ( ( B ) ) ) ，

union X{
    int x;
    char y[4]; 
};

0x11
0x12
0x33
0x44

第三十三題 - 指標

33、 對于指標的描述，正確的是 ( ( ( D ) ) ) ，

指標就是參考
指標都是 8 位元組
陣列就是指標
指標可以進行自增操作

第三十四題 - 補碼

34、 -1 的補碼是 ( ( ( A ) ) ) ，

0xffffffff
0xfffffff1
0x00000001
0xfffffffe

第三十五題 - 類

35、 有關 C++ 中類的描述，錯誤的是 ( ( ( A ) ) ) ，

struct和 class都可以表示類，沒有區別
類的關鍵字是class
類可以是私有的
類可以是公有的

第三十六題 - 進制轉換

36、 對于十六進制數 0x1000，錯誤的是 ( ( ( A ) ) ) ，

它的十進制表示為 1000
它是一個有理數
它能被 16 整除
它是一個整數

第三十七題 - 位與運算

37、 0xef0f 位與 0xfef3 的結果為 ( ( ( B ) ) ) ，

0xef03
0xee03
0xfe03
0xeef3

第三十八題 - 位或運算

38、 0xef0f 位或 0xfef3 的結果為 ( ( ( B ) ) ) ，

0xefff
0xffff
0xfef3
0xeeff

第三十九題 - 異或運算

39、 0xef0f 異或 0xfef3 的結果為 ( ( ( B ) ) ) ，

0x00cf
0x11fc
0x01fc
0x10cf

第四十題 - 按位取反運算

40、 ~0 的結果為 ( ( ( A ) ) ) ，

-1
0
1
2

第四十一題 - 左移位運算

41、 1 左移 10 位的結果為 ( ( ( C ) ) ) ，

1
10
1024
10000000000

第四十二題 - 右移位運算

42、 1 右移 10 位的結果為 ( ( ( C ) ) ) ，

1024
10
0
10000000000

第四十三題 - 右移位運算

43、 1 右移 10 位的結果為 ( ( ( C ) ) ) ，

1024
10
0
10000000000

第四十四題 - 虛函式

44、 有關 C++ 虛函式的概念，錯誤的是 ( ( ( C ) ) ) ，

解構式可以是虛函式
虛函式的關鍵字是 virtual
建構式可以是虛函式
虛函式也占用記憶體空間

第四十五題 - 建構式

45、 有關 C++ 建構式的概念，錯誤的是 ( ( ( C ) ) ) ，

建構式沒有回傳值
類可以不定義建構式
建構式可以是虛函式
建構式可以沒有引數

第四十六題 - 記憶體泄漏

46、 有關 C++ 記憶體泄漏的概念，錯誤的是 ( ( ( C ) ) ) ，

記憶體泄漏以后程式仍然能夠正常運行
為了避免記憶體泄漏，解構式宣告為虛函式
記憶體泄漏以后程式就崩潰了
為了避免記憶體泄漏，可以使用智能指標

第四十七題 - 常量

47、 下列的常量定義中，錯誤的定義是 ( ( ( C ) ) ) ，

const int a = 20;
const double b = 20;
const char c;
const float a = 0;

第四十八題 - 建構式

48、 在 C++ 中的結構體是否可以有建構式？ ( ( ( C ) ) ) ，

不可以，結構型別不支持成員函式
可以，和類的功能一樣
可以，和類的功能有區別
不可以，只有類才允許有建構式

第四十九題 - 回圈

49、 for(int x = 0 , y = 0; !x && y <= 5 ; y++)陳述句執行回圈的次數是多少次？ ( ( ( B ) ) ) ，

5
6
7
無數次

第五十題 - 回圈

50、 給出一段代碼，問程式運行后輸出結果為多少？ ( ( ( B ) ) ) ，

int main() {
    int m = 12, n = 34;
    printf("%d%d", m++,++n);
    printf("%d%d\n", n++,++m);
}

12353513
12353514
12343514
12343513

第五十一題 - 回圈

51、 執行 x=-1; do { x=x*x; } while (!x);回圈時，下列說法正確的是 ( ( ( A ) ) ) ，

回圈體將執行 1 次
回圈體將執行 2 次
回圈體將執行無限次
回圈體將執行 0 次

第五十二題 - 回圈

52、 int x=3; do { printf("%d",x--);} while(!x);該程式的輸出結果是 ( ( ( A ) ) ) ，

3
32
321
3210

第五十三題 - 常量

53、 以下不能作為合法常量的是 ( ( ( B ) ) ) ，

1.233e2
1.4556e5.6
1.34e06
1.4664e-5

第五十四題 - 參考

54、 int a, &ra=a;關于 ra 的描述中正確的是 ( ( ( B ) ) ) ，

它是變數 a 的地址
它是變數 a 的參考
它是變數 a 的解參考
它是變數 a 的解指標

第五十五題 - 建構式

55、 關于以下代碼，哪個說法是正確的？ ( ( ( D ) ) ) ，

cls::foo(){
    delete this;
}
..
void func(){
    cls *a = new cls();
    a->foo();
}

堆疊溢位
無法編譯
段錯誤
都不正確

第五十六題 - 智能指標

56、 下列關于 shared_ptr 說法正確的是 ( ( ( A ) ) ) ，

容器可以作為 shared_ptr 管理的物件
使用 shared_ptr 一定可以避免記憶體泄漏
shared_ptr 是執行緒安全的
容器不可以作為 shared_ptr 管理的物件

第五十七題 - 記憶體分配

57、 下列 new / delete 說法錯誤的是 ( ( ( A ) ) ) ，

new / delete 是 C++ 的庫函式
delete 會呼叫物件的解構式
new 會呼叫建構式
new / delete 是 C++ 的運算子

第五十八題 - 記憶體分配

58、 下列 new / delete 說法正確的是 ( ( ( A ) ) ) ，

new / delete 不是 C++ 的庫函式
delete 不會呼叫物件的解構式
new 不會呼叫建構式
new / delete 不是 C++ 的運算子

第五十九題 - C++性質

59、 以下哪個不是 C++ 的特點 ( ( ( C ) ) ) ，

繼承
多型
宣告
封裝

第六十題 - 位與運算

60、 根據以下程式，當呼叫 func(9999)，輸出值為 ( ( ( C ) ) ) ，

int func(x) {
    int ctx = 0; 
    while(x) { 
        ctx ++;
        x = x & (x-1); 
    } 
    return ctx;
}

第六十一題 - 位與運算

61、 根據以下程式，當呼叫 func(7777)，輸出值為 ( ( ( B ) ) ) ，

int func(x) {
    int ctx = 0; 
    while(x) { 
        ctx ++;
        x = x & (x-1); 
    } 
    return ctx;
}

第六十二題 - 指標和參考

62、 有關指標和參考的說法，錯誤的是 ( ( ( C ) ) ) ，

參考必須被初始化，指標不必
參考初始化以后不能被改變，指標可以改變所指的物件
參考可以轉換為指標，指標無法轉換成參考
不存在指向空值的參考，但是存在指向空值的指標

第六十三題 - 例外

63、 int a = 8, b = 0, c;, 執行陳述句 c = a / b + 0.5;后, c的值為 ( ( ( C ) ) ) ，

1.5
2.1
除零錯
0

第六十四題 - 靜態變數

64、 在C語言中，關于靜態變數的說法，錯誤的是 ( ( ( C ) ) ) ，

靜態全域變數作用域不是一個程式的所有源檔案
靜態變數和常量不相同
函式中的靜態變數，在函式退出后釋放
靜態變數可以賦值多次

第六十五題 - 編譯

65、 一個 C++ 專案中有 9 個 .h 檔案，55 個 .cpp 檔案，編譯之后生成的 .obj 檔案的數量是 ( ( ( B ) ) ) ，

第六十六題 - 指標

66、 設有如下的程式段 char *ptr = NULL; char str[] = "hehe"; ptr = str;，執行完上面的程式段后，*(ptr + 191)的值為 ( ( ( C ) ) ) ，

‘e’
‘\0’
不確定的值
‘e’ 的地址

第六十七題 - 輸入

67、 有如下陳述句序列：char str[10]; cin>>str;
當從鍵盤輸入I-love this blog時，str中的字串是 ( ( ( C ) ) ) ，

I love this blog
I love thi
I-love
I

第六十八題 - 設計模式

68、 在結構化的程式設計中，對模塊劃分的原則的描述，不正確的是 ( ( ( B ) ) ) ，

模塊間的聯系不是越緊密越好
模塊功能越多越好
模塊間具有低耦合
模塊內具有高內聚

第六十九題 - 變數

69、 下面的型別宣告中正確是 ( ( ( A ) ) ) ，

int a[4] = {5};
int b=
int &c
int d, *e = null

第七十題 - 進制轉換

70、 0x90abcdef 轉換成二進制的值是 ( ( ( A ) ) ) ，

0b10010000101010111100110111101111
0b10010000101010111100110111011111
0b10010000101110111100110111101111
0b10010000101010111101110111101111

第七十一題 - 賦值運算子

71、 x = 3; x += x -= x*x;執行完畢以后，x的值為 ( ( ( B ) ) ) ，

-30
-12
-24
-3

第七十二題 - 變數

72、 int 型別值的數值范圍為 ( ( ( C ) ) ) ，

[ 0 , 2 31 ? 1 ] [0, 2^{31}-1] [0,231?1]
[ 0 , 2 32 ? 1 ] [0, 2^{32}-1] [0,232?1]
[ ? 2 31 , 2 31 ? 1 ] [-2^{31}, 2^{31}-1] [?231,231?1]
[ ? 2 31 , 2 31 ] [-2^{31}, 2^{31}] [?231,231]

第七十三題 - 全域變數

73、 關于全域變數，下列說法錯誤的是 ( ( ( A ) ) ) ，

全域變數不可用于函式之間傳遞資料
全域變數不是越多越好
全域變數的生命周期和區域變數不同
任何全域變數不是都可以被應用系統匯總任何程式檔案中的任何函式訪問

第七十四題 - 函式宣告

74、 對于以下函式宣告，正確的是 ( ( ( B ) ) ) ，

func(int, int)
void func(int,int)
func(int a, int b)
int func(int g = 0, int gg)

第七十五題 - 進制

75、 哪個表示的是八進制？ ( ( ( B ) ) ) ，

012345678
01234567
0b0101
0x12345678

第七十六題 - 進制

76、 哪個表示的是二進制？ ( ( ( C ) ) ) ，

01234
0x1234
0b0001
008

第七十七題 - 靜態變數

77、 靜態區域變數存盤在行程的 ( ( ( C ) ) ) ，

堆疊區
暫存器區
全域區
堆區

第七十八題 - 運算子優先級

78、 對于運算式(5 += 5)的值是 ( ( ( D ) ) ) ，

10
5
0
語法錯誤

第七十九題 - 運算子優先級

79、 對于運算式(a + !-b **c / *d)，共有 ( ( ( C ) ) ) 個一元運算子，

第八十題 - 型別轉換

80、 char w; int x; float y; unsigned int z;則運算式: w * x - z + y值的資料型別是 ( ( ( A ) ) ) ，

float
unsigned int
int
char

第八十一題 - 逗號運算式

81、 (rec1,rec2+rec3,(rec4,rec5));運算式最終的值是 ( ( ( D ) ) ) ，

rec1
rec2
rec4
rec5

第八十二題 - 位元組序

82、 X 定義如下，若存在 X a; a.x=0x98765432;則 a.y[2]的值可能為 ( ( ( A ) ) ) ，

union X{
    int x;
    char y[4]; 
};

0x76
0x89
0x67
0x45

第八十三題 - 指標

83、 對于指標的描述，正確的是 ( ( ( C ) ) ) ，

指標就是參考
指標就是陣列
陣列不能進行自增操作
指標不能進行自增操作

第八十四題 - 補碼

84、 -2 的補碼是 ( ( ( A ) ) ) ，

0xfffffffe
0xfffffff1
0x00000001
0xfffffffe

第八十五題 - 類

85、 有關 C++ 中類的描述，錯誤的是 ( ( ( A ) ) ) ，

struct和 class都可以表示類，沒有區別
類的關鍵字是class
結構體的關鍵字是struct
類可以是私有的

第八十六題 - 進制轉換

86、 對于十六進制數 0x10，正確的是 ( ( ( C ) ) ) ，

它的八進制表示為 20
它的二進制表示為 1010
它的十進制表示為 16
它的十六進制表示不止一種

第八十七題 - 位與運算

87、 6666 位與 8888 的結果為 ( ( ( C ) ) ) ，

1314
2222
520
890

第八十八題 - 位或運算

88、 6666 位或 8888 的結果為 ( ( ( A ) ) ) ，

15034
6688
51304
49501

第八十九題 - 異或運算

89、 6666 異或 8888 的結果為 ( ( ( D ) ) ) ，

1513
4514
14513
14514

第九十題 - 按位取反運算

90、 ~-1 的結果為 ( ( ( A ) ) ) ，

0
-1
1
-2

第九十一題 - 左移位運算

91、 1 左移 x x x 位的值為 ( ( ( B ) ) ) ，

1 x 1^x 1x
2 x 2^x 2x
x 2 x^2 x2
x x x

第九十二題 - 右移位運算

92、 1 右移 x x x 位相當于 ( ( ( A ) ) ) ，

1 2 x \frac 1 {2^x} 2x1?
1 2 \frac 1 {2} 21?
1 x 2 \frac 1 {x^2} x21?
1 x x \frac 1 {x^x} xx1?

第九十三題 - 右移位運算

93、 1 右移 5 位的結果為 ( ( ( C ) ) ) ，

1024
10
0
10000000000

第九十四題 - 虛函式

94、 有關 C++ 虛函式的概念，正確的是 ( ( ( A ) ) ) ，

解構式可以是虛函式
解構式必須是虛函式
建構式可以是虛函式
虛函式不占用記憶體空間

第九十五題 - 建構式

95、 有關 C++ 建構式的概念，正確的是 ( ( ( A ) ) ) ，

建構式沒有回傳值
類不可以不定義建構式
建構式不可以是虛函式
建構式不可以沒有引數

第九十六題 - 記憶體泄漏

96、 有關 C++ 記憶體泄漏的概念，錯誤的是 ( ( ( A ) ) ) ，

只要運行效率高，記憶體泄漏不是大問題
為了避免記憶體泄漏，解構式宣告為虛函式
記憶體泄漏以后，程式可能還能繼續運行
為了避免記憶體泄漏，可以使用智能指標

第九十七題 - 常量

97、 下列的常量定義中，錯誤的定義是 ( ( ( A ) ) ) ，

const int a = a;
const double b = 20;
const char c = 5.20f;
const float a = 0;

第九十八題 - 建構式

98、 在 C++ 中的結構體是否可以有建構式？ ( ( ( C ) ) ) ，

不可以，結構型別不支持成員函式
可以，和類的功能一樣
可以，和類的功能有區別
不可以，只有類才允許有建構式

第九十九題 - 回圈

99、 for(int x = 0 , y = 0; y <= 5 ; y += x)陳述句執行回圈的次數是多少次？ ( ( ( D ) ) ) ，

5
6
7
無數次

第一百題 - 回圈

100、 以下哪個 while 陳述句是死回圈 ( ( ( B ) ) ) ，

while(1) { break; }
while(1) { int a = 5; ++a;}
int a = 1; while(a++) {}
int a = 10; while(a--);

第一百零一題 - 遞回

101、 對于以下遞回函式 f f f，呼叫 f ( 4 ) f(4) f(4)，其回傳值為 ( ( ( D ) ) ) ，

int f(int n) {
    if (n > 1)
        return f(n - 1) + f(n - 2);
    return 1;
}

第一百零二題 - 運算子

102、 以下哪個運算子不能多載 ( ( ( C ) ) ) ，

+=
>>
sizeof
+

第一百零三題 - 字串

103、 程式char c[5]={'a','b','\,','c','\0'}; printf("%s",c);的運行結果是 ( ( ( A ) ) ) ，

ab,c
abc
ab c
ab

第一百零四題 - 智能指標

104、 下面關于 shared_ptr 說法錯誤的有 ? ( ( ( C ) ) ) ，

使用 shared_ptr 可以一定程度上避免記憶體泄漏
兩個 shared_ptr 物件物體可以被兩個執行緒同時寫入
多執行緒讀寫同一個 shared_ptr 物件不需要加鎖,因為shared_ptr 物件本身是執行緒安全的
使用 shared_ptr 時候最好使用 make_shared 來分配記憶體

第一百零五題 - 解構式

105、 對于解構式的描述，錯誤的是 ( ( ( B ) ) ) ，

解構式在 delete 時會呼叫到
任何一個物件的解構式一定會被呼叫到
STL 的 vector 也有解構式
解構式中可以呼叫成員變數

第一百零六題 - 指標

106、 64位系統下，*p = new char[100]， sizeof(p)為多少？ ( ( ( D ) ) ) ，

第一百零七題 - 溢位

107、 1 加上 2 32 ? 1 2^{32}-1 232?1 的結果為 ( ( ( D ) ) ) ，

0
2 32 2^{32} 232
2 31 2^{31} 231
不一定

第一百零八題 - 字串

108、 字串"A\0+K=47\n"的長度為 ( ( ( D ) ) ) ，

第一百零九題 - 變數

109、 下面的型別宣告中正確是 ( ( ( D ) ) ) ，

int &a[4];
int &b = 5
int &c
int d, *e = &d, **f = &e;

第一百十題 - 進制轉換

110、 以下哪個式子有可能在某個進制下成立 ( ( ( B ) ) ) ，

0 + 0= 15
1 + 1 = 10
14 + 14 = 0
1 + 1 = 109

第一百十一題 - 賦值運算子

111、 x = 666; x -= x += x*x;執行完畢以后，x的值為 ( ( ( B ) ) ) ，

666
0
24358
145436

第一百十二題 - 變數

112、 unsigned char 型別值的數值范圍為 ( ( ( C ) ) ) ，

0 ~ 32767
0 ~ 65535
0 ~ 255
0 ~ 256

第一百十三題 - 全域變數

113、 關于全域變數，下列說法正確的是 ( ( ( A ) ) ) ，

全域變數可用于函式之間傳遞資料
任何全域變數都只能被定義它的函式中的陳述句訪問
任何全域變數都只能被定義它的程式檔案中的函式訪問
全域變數和區域變數功能相同

第一百十四題 - 函式

114、 如果函式不需要任何回傳值，使用什么形式的函式宣告？ ( ( ( B ) ) ) ，

func()
void func( void )
static func(void)
int func() const

第一百十五題 - 整型

115、 哪個表示的是十六進制？ ( ( ( B ) ) ) ，

016
0x16
0b16
16

第一百十六題 - 整型

116、 哪個表示的是八進制？ ( ( ( A ) ) ) ，

01234
0x12
0b01
08

第一百十七題 - 靜態變數

117、 靜態區域變數存盤在行程的 ( ( ( D ) ) ) ，

代碼區
靜態區
堆疊區
全域區

第一百十八題 - 運算子

118、 運算式-&a[b]->c和以下 ( ( ( B ) ) ) 等價，

-(&a)[b]->c
-&(a[b])->c
-&((a[b])->c)
(-&)a[b]->c

第一百十九題 - 運算子

119、 以下哪個運算子的優先級最低 ( ( ( D ) ) ) ，

第一百二十題 - 型別轉換

120、 char w; int x; float y; double z;則運算式: x * x + x - w值的資料型別是 ( ( ( C ) ) ) ，

float
double
int
char

第一百二十一題 - 逗號運算式

121、 函式呼叫陳述句func(rec1,rec2,(rec3,rec4,rec5));中的實參的個數是 ( ( ( A ) ) ) ，

第一百二十二題 - 邏輯運算子

122、 以下哪個運算式的結果為真 ( ( ( C ) ) ) ，

~(a || a)
!a && a
!a || a
!a || a && !a

第一百二十三題 - 算術運算子

123、 -5 % -3 的結果是 ( ( ( B ) ) ) ，

2
-2
-5
-3

第一百二十四題 - 虛函式

124、 有關 C++ 虛函式的概念，正確的是 ( ( ( B ) ) ) ，

解構式不可以是虛函式
虛函式的關鍵字是 virtual
建構式可以是虛函式
虛函式不占用記憶體空間

第一百二十五題 - 建構式

125、 有關 C++ 建構式的概念，正確的是 ( ( ( C ) ) ) ，

建構式有回傳值
類不可以不定義建構式
建構式不可以是虛函式
建構式不可以沒有引數

第一百二十六題 - 記憶體泄漏

126、 有關 C++ 記憶體泄漏的概念，錯誤的是 ( ( ( C ) ) ) ，

智能指標可以預防記憶體泄漏
為了避免記憶體泄漏，解構式可以宣告為虛函式
記憶體泄漏以后程式就崩潰了
為了避免記憶體泄漏，可以使用智能指標

第一百二十七題 - 常量

127、 下列的常量定義中，錯誤的定義是 ( ( ( C ) ) ) ，

const int a = 520;
const double b = 1314;
const char c;
const float a = 05201314;

第一百二十八題 - 建構式

128、 在 C++ 中的結構體是否可以有建構式？ ( ( ( D ) ) ) ，

不可以，結構型別不支持成員函式
可以，和類的功能一樣
不可以，只有類才允許有建構式
可以，和類的功能有區別

第一百二十九題 - 回圈

129、 for(int x = 0; x <= 1313; x++)陳述句執行回圈的次數是多少次？ ( ( ( B ) ) ) ，

1313
1314
1315
無數次

第一百三十題 - 進制轉換

130、 給出一段代碼，問程式運行后輸出結果為多少？ ( ( ( B ) ) ) ，

int main() {
    int n = 1032, m = 045;
    printf("%d", m+++n++);
}

1069
1072
1070
1071

第一百三十一題 - 回圈

131、 執行 x=-1; do { x=x*x; } while (~x);回圈時，下列說法正確的是 ( ( ( D ) ) ) ，

回圈體將執行 1 次
回圈體將執行 2 次
回圈體將執行無限次
回圈體將執行 0 次

第一百三十二題 - 回圈

132、 int x=3; do { printf("%d",x--);} while(x);該程式的輸出結果是 ( ( ( C ) ) ) ，

3
32
321
3210

第一百三十三題 - 常量

133、 以下不能作為合法常量的是 ( ( ( B ) ) ) ，

1.233e2
1.6764e5.6
1.31e06
1.46114e-5111

第一百三十四題 - 參考

134、 int a, &ra=a;關于 ra 的描述中正確的是 ( ( ( B ) ) ) ，

它是變數 a 的地址
它是變數 a 的別名
它是變數 a 的解參考
它是變數 a 的解指標

第一百三十五題 - 建構式

135、 關于以下代碼，哪個說法是正確的？ ( ( ( D ) ) ) ，

cls::foo(){
    delete this;
}
..
void func(){
    cls *a = new cls();
    a->foo();
}

堆疊溢位
無法編譯
段錯誤
未知

第一百三十六題 - 智能指標

136、 下列關于 shared_ptr 說法正確的是 ( ( ( D ) ) ) ，

使用 shared_ptr 一定可以避免記憶體泄漏
shared_ptr 是執行緒安全的
容器不可以作為 shared_ptr 管理的物件
容器可以作為 shared_ptr 管理的物件

第一百三十七題 - 記憶體分配

137、 下列 new / delete 說法正確的是 ( ( ( D ) ) ) ，

new / delete 是 C++ 的庫函式
delete 會呼叫物件的建構式
new 會呼叫解構式
new / delete 是 C++ 的運算子

第一百三十八題 - 建構式

138、 ( ( ( A ) ) ) 不是建構式的特征，

建構式必須制定型別說明
建構式的函式名與類名相同
建構式可以多載
建構式可以設定默認引數

第一百三十九題 - sizeof

139、 32位系統中，以下代碼輸出 ( ( ( C ) ) ) ，

#include <stdio.h>
#include <string.h>

void pFunc(char s[100]) {
    printf("%d",sizeof(s));
}

int main(void) {
    char str[] = "Hello";
    printf("%d",sizeof(str));
    printf("%d",strlen(str));
    char*p=str;
    printf("%d",sizeof(p));
    pFunc(str);
}

6564
5544
6544
555100

第一百四十題 - 模板

140、 有如下模板定義：template <class T> T fun(T x,T y) {return x*x + y*y; }在下列對 fun 的呼叫中，錯誤的是： ( ( ( C ) ) ) ，

fun(1,2)
fun(2.0,4.0)
fun(1.8,10)
fun(3.5f,5.6f)

第一百四十一題 - 記憶體

141、 以下代碼輸出結果是 ( ( ( C ) ) ) ，

#include <stdio.h>
#include <string.h>
#include <malloc.h>
void Test(void)
{
    char *str = (char *) malloc(100);
    strcpy(str, "hello");
    free(str);
    if (str) {
        strcpy(str, "world");
        printf(str);
    }
}
int main(void) {
    Test();
}

hello
world
未定義行為
helloworld

第一百四十二題 - 編譯原理

142、 有關鏈接的說法，錯誤的是 ( ( ( D ) ) ) ，

鏈接分為靜態鏈接和動態鏈接
靜態鏈接即代碼從其所在的靜態鏈接庫中拷貝到最終的可執行程式中，在該程式被執行時，這些代碼會被裝入到該行程的虛擬地址空間中，
動態鏈接即代碼被放到元件或共享物件的某個目標檔案中，鏈接程式只是在最終的可執行程式中記錄了共享物件的名字等一些資訊，在程式執行時，元件的全部內容會被映射到運行時相應進行的虛擬地址的空間，
靜態鏈接比較浪費空間，每個可執行程式都會有目標檔案的一個副本，這樣如果目標檔案進行了更新操作，就需要重新進行編譯鏈接生成可執行程式，更新較方便

第一百四十三題 - 編譯原理

143、 編譯程序分為四個程序，錯誤的是 ( ( ( D ) ) ) ，

編譯預處理
匯編
鏈接
運行

第一百四十四題 - 記憶體管理

144、 以下哪個不是 c++ 的記憶體磁區 ( ( ( D ) ) ) ，

堆
堆疊
佇列
代碼區

第一百四十五題 - 記憶體管理

145、 函式中通過 new 申請的空間在 ( ( ( D ) ) ) 上，

堆
堆疊
全域區
代碼區

第一百四十六題 - 排序

146、 對下文的代碼注釋，描述錯誤的是 ( ( ( D ) ) ) ，

#include <stdio.h>

int n, a[1010];

void swap(int *a, int *b) {             // (1)
    int tmp = *a;
    *a = *b;
    *b = tmp;
}

int main() {
    int i, j;
    while(scanf("%d", &n) != EOF) {
        for(i = 0; i < n; ++i) {
            scanf("%d", &a[i]);
        }
        for(i = 0; i < n - 1; ++i) {
            int min = i;                 // (2)
            for(j = i+1; j < n; ++j) {   // (3)
                if(a[j] < a[min]) {
                    min = j; 
                }
            }
            swap(&a[i], &a[min]);        // (4) 
        }
        
        for(i = 0; i < n; ++i) {
            if(i) 
                printf(" ");
            printf("%d", a[i]);
        }
        puts("");
    }
    return 0;
}

( 1 ) (1) (1) 實作的是變數交換；
( 2 ) (2) (2) 默認最小的那個元下標是 i i i；
( 3 ) (3) (3) 從a[i]到a[n-1]選擇一個最小的數，記錄下標在min中；
( 4 ) (4) (4) 將a[i]和a[min]進行交換，其中 & 代表參考；

第一百四十七題 - 常量

147、 下列的常量定義中錯誤的定義是 ( ( ( C ) ) ) ，

const int a = 20;
const double b = 20;
const char char = 8;
const float a = 0;

第一百四十八題 - 排序

148、 以下這段代碼是對陣列進行排序，請說出它是什么排序 ( ( ( D ) ) ) ，

#include <stdio.h>
#include <string.h>

#define maxn 1000001
#define maxk 100001

int a[maxn];
int cnt[maxk]; 

void Input(int n, int *a) {
    for(int i = 0; i < n; ++i) {
        scanf("%d", &a[i]);
    }
}

void Output(int n, int *a) {
    for(int i = 0; i < n; ++i) {
        if(i)
            printf(" ");
        printf("%d", a[i]);
    }
    puts("");
}

void CountingSort(int n, int *a) {       // (1)
    int i, top; 
    memset(cnt, 0, sizeof(cnt));         // (2) 
    for(i = 0; i < n; ++i) {             // (3)
        ++cnt[ a[i] ];                   // (4)
    }
    top = 0;                             // (5)
    for(i = 0; i < maxk; ++i) {
        while(cnt[i]) {                  // (6)
            a[top++] = i;                // (7)
            --cnt[i];                    // (8)
        }
        if(top == n) {                   // (9)
            break;
        }
    }
} 

int main() {
    int n;
    while(scanf("%d", &n) != EOF) {
        Input(n, a);
        CountingSort(n, a);
        Output(n, a);
    }
    return 0;
}

冒泡排序
選擇排序
基數排序
計數排序

第一百四十九題 - 回圈

149、 t = 100; while(t--) {}陳述句執行回圈的次數是多少次？ ( ( ( B ) ) ) ，

99
100
101
無數次

第一百五十題 - 回圈

150、 給出一段代碼，問程式運行后輸出結果為多少？ ( ( ( D ) ) ) ，

#include <stdio.h>
#include <string.h>
#include <malloc.h>

int main(void) {
    int i, j, k;
    for(i = 0; i < 10; ++i) {
        for(j = i+1; j < 10; ++j) {
            for(k = j+1; j < 10; ++k) {
                ++i;
            }
        }
    }
    printf("%d%d%d\n", i, j, k);
}

101010
101112
1098
無任何輸出

第一百五十一題 - 回圈

151、 執行如下代碼，下列說法正確的是 ( ( ( B ) ) ) ，

#include <stdio.h>
#include <string.h>
#include <malloc.h>
int x, c = 0;

int main(void) {
    x = -1;
    do { 
        x = x*x;
        --x;
        ++c;
    } while (!x);
    printf("%d\n", c);
}

回圈體將執行 1 次
回圈體將執行 2 次
回圈體將執行無限次
回圈體將執行 0 次

第一百五十二題 - 回圈

152、 int x=3; do { printf("%d",x--);} while(!x + 4);該程式的輸出結果是 ( ( ( A ) ) ) ，

輸出霸屏
32
321
3210

第一百五十三題 - 常量

153、 以下不能作為合法常量的是 ( ( ( B ) ) ) ，

1.233e21
1.234e5.6
1.35646456e06
1.4664768768e-5

第一百五十四題 - 參考

154、 int b, &rb=b;關于 ra 的描述中正確的是 ( ( ( B ) ) ) ，

它是變數 b 的地址
它是變數 b 的參考
它是變數 b 的解參考
它是變數 b 的解指標

第一百五十五題 - 建構式

155、 關于以下代碼，哪個說法是正確的？ ( ( ( D ) ) ) ，

cls::foo(){
    delete this;
}
..
void func(){
    cls *a = new cls();
    a->foo();
}

堆疊溢位
無法編譯
段錯誤
未定義

第一百五十六題 - 記憶體分配

156、 下列關于堆疊的說法錯誤的是 ( ( ( D ) ) ) ，

堆疊是系統自動分配，堆是程式員主動申請，
分配堆疊空間，如果剩余空間大于申請空間則分配成功，否則分配失敗堆疊溢位
申請堆空間，堆在記憶體中呈現的方式類似于鏈表（記錄空閑地址空間的鏈表），在鏈表上尋找第一個大于申請空間的節點分配給程式，將該節點從鏈表中洗掉，大多數系統中該塊空間的首地址存放的是本次分配空間的大小，便于釋放，將該塊空間上的剩余空間再次連接在空閑鏈表上
堆在記憶體中是連續的一塊空間（向低地址擴展）最大容量是系統預定好的，堆疊在記憶體中的空間（向高地址擴展）是不連續的

第一百五十七題 - 記憶體分配

157、 下列關于堆疊的說法錯誤的是 ( ( ( D ) ) ) ，

堆疊中存放的是區域變數，函式的引數
堆中存放的內容由程式員控制
堆是由程式員主動申請，效率低，使用起來方便但是容易產生碎片
堆疊是有系統自動分配，申請效率低，程式員無法控制

第一百五十八題 - 記憶體分配

158、 下列關于 C++ 記憶體磁區的說法，錯誤的是 ( ( ( D ) ) ) ，

堆疊：存放函式的區域變數、函式引數、回傳地址等，由編譯器自動分配和釋放
堆：動態申請的記憶體空間，就是由 malloc 分配的記憶體塊，由程式員控制它的分配和釋放，如果程式執行結束還沒有釋放，作業系統會自動回收
常量存盤區：存放的是常量，不允許修改，程式運行結束自動釋放
代碼區：存放代碼，允許修改，可以執行，編譯后的二進制檔案存放在這里

第一百五十九題 - 編譯原理

159、 以下關于鏈接的說法，錯誤的是 ( ( ( A ) ) ) ，

靜態鏈接：代碼從其所在的靜態鏈接庫中拷貝到最終的可執行程式中，在該程式被執行時，這些代碼會被裝入到該行程的物理地址空間中
動態鏈接：代碼被放到元件或共享物件的某個目標檔案中，鏈接程式只是在最終的可執行程式中記錄了共享物件的名字等一些資訊，在程式執行時，元件的全部內容會被映射到運行時相應進行的虛擬地址的空間
靜態鏈接：浪費空間，每個可執行程式都會有目標檔案的一個副本，這樣如果目標檔案進行了更新操作，就需要重新進行編譯鏈接生成可執行程式（更新困難）；優點就是執行的時候運行速度快，因為可執行程式具備了程式運行的所有內容，
動態鏈接：節省記憶體、更新方便，但是動態鏈接是在程式運行時，每次執行都需要鏈接，相比靜態鏈接會有一定的性能損失，

第一百六十題 - 位與運算

160、 根據以下程式，當呼叫 func(8888)，輸出值為 ( ( ( A ) ) ) ，

int func(int x) {
    int ctx = 0; 
    while(x) { 
        ctx ++;
        x = x & (x-1); 
    } 
    return ctx;
}

第一百六十一題 - 位與運算

161、 根據以下程式，當呼叫 func(6666)，輸出值為 ( ( ( A ) ) ) ，

int func(x) {
    int ctx = 0; 
    while(x) { 
        ctx ++;
        x = x & (x-1); 
    } 
    return ctx;
}

第一百六十二題 - 指標和參考

162、 有關指標和參考的說法，錯誤的是 ( ( ( A ) ) ) ，

參考可以轉換為指標，指標無法轉換成參考
參考必須被初始化，指標不必
參考初始化以后不能被改變，指標可以改變所指的物件
不存在指向空值的參考，但是存在指向空值的指標

第一百六十三題 - 算術運算子

163、 int a = 9, b = 2, c;, 執行陳述句 c = a / b + 0.5;后, c的值為 ( ( ( C ) ) ) ，

第一百六十四題 - 靜態變數

164、 在C語言中，關于靜態變數的說法，正確的是 ( ( ( D ) ) ) ，

靜態全域變數作用域在一個程式的所有源檔案
靜態變數和常量相同
函式中的靜態變數，在函式退出后釋放
靜態變數可以賦值多次

第一百六十五題 - extern關鍵字

165、 有關 extern 關鍵字的表述，錯誤的是 ( ( ( C ) ) ) ，

extern 置于變數或函式前，用于標示變數或函式的定義在別的檔案中，提示編譯器遇到此變數和函式時在其他模塊中尋找其定義
當它與“C”一起連用的時候，如：extern "C" void f(int a,int b);則告訴編譯器在編譯fun這個函式時候按著C的規矩去翻譯，而不是C++的
當它與“C++”一起連用的時候，如：extern "C++" void f(int a,int b);則告訴編譯器在編譯fun這個函式時候按著C++的規矩去翻譯，而不是C的
當extern不與“C”在一起修飾變數或函式時，如：extern int g_val;它的作用就是宣告函式或全域變數的作用范圍的關鍵字，其宣告的函式和變數可以在本模塊或其他模塊中使用

第一百六十六題 - static關鍵字

166、 有關 static 關鍵字的表述，錯誤的是 ( ( ( C ) ) ) ，

static修飾區域變數時，使得被修飾的變數成為靜態變數，存盤在靜態區，存盤在靜態區的資料生命周期與程式相同，在main函式之前初始化，在程式退出時銷毀，（無論是區域靜態還是全域靜態）
全域變數本來就存盤在靜態區，因此static并不能改變其存盤位置，但是，static限制了其鏈接屬性，被static修飾的全域變數只能被該包含該定義的檔案訪問（即改變了作用域）
static修飾函式使得函式只能在包含該函式定義的檔案中被呼叫，對于靜態函式，宣告和定義不能放在同一個檔案夾中
用static修飾類的資料成員使其成為類的全域變數，會被類的所有物件共享，包括派生類的物件，所有的物件都只維持同一個實體

第一百六十七題 - volatile關鍵字

167、 有關 volatile 關鍵字的表述，正確的是 ( ( ( C ) ) ) ，

用來修飾變數的，表明某個變數的地址可能會隨時被外部改變，因此這些變數的存取不能被快取到暫存器，每次使用需要重新讀取
用來修飾變數的，表明某個變數的值可能會隨時被外部改變，因此這些變數的存盤不能被快取到暫存器，每次使用需要重新讀取
用來修飾變數的，表明某個變數的值可能會隨時被外部改變，因此這些變數的存取不能被快取到暫存器，每次使用需要重新讀取
用來修飾變數的，表明某個變數的地址可能會隨時被外部改變，因此這些變數的存盤不能被快取到暫存器，每次使用需要重新讀取

第一百六十八題 - const關鍵字

168、 有關 const 關鍵字的表述，不正確的是 ( ( ( D ) ) ) ，

定義變數為只讀變數，不可修改
修飾函式的引數和回傳值
常成員函式修飾，使得函式不能修改成員變數
const *int p中p代表指標常量

第一百六十九題 - 參考

169、 有關指標和參考的貓叔，錯誤的是 ( ( ( D ) ) ) ，

指標只是一個變數，只不過這個變數存盤的是一個地址
參考跟原來的變數實質上是同一個東西，只不過是原變數的一個別名而已，不占用記憶體空間
參考必須在定義的時候初始化，而且初始化后就不能再改變
指標和參考都可以有多級

第一百七十題 - 多型

170、 有關c++的多型，表述錯誤的是 ( ( ( D ) ) ) ，

多型性可以簡單地概括為“一個介面，多種方法”，程式在運行時才決定呼叫的函式
C++多型性主要是通過函式多載和虛函式實作的
多型與非多型的實質區別就是函式地址是早系結還是晚系結
編譯時多型性通過通過虛函式實作

第一百七十一題 - 動態系結

171、 關于動態系結，表述錯誤的是 ( ( ( A ) ) ) ，

動態系結發生在編譯期
要想實作多型，必須使用動態系結
在繼承體系中只有虛函式使用的是動態系結，其他的全部是靜態系結
動態多型是指通過虛函式動態系結的技術

第一百七十二題 - 變數

172、 unsigned int 型別值的數值范圍為 ( ( ( B ) ) ) ，

[ 0 , 2 31 ? 1 ] [0, 2^{31}-1] [0,231?1]
[ 0 , 2 32 ? 1 ] [0, 2^{32}-1] [0,232?1]
[ ? 2 31 , 2 31 ? 1 ] [-2^{31}, 2^{31}-1] [?231,231?1]
[ ? 2 31 , 2 31 ] [-2^{31}, 2^{31}] [?231,231]

第一百七十三題 - 全域變數

173、 關于全域變數，下列說法錯誤的是 ( ( ( A ) ) ) ，

全域變數就是所有區域變數的并
全域變數并不是越多越好
全域變數的生命周期和區域變數不同
任何全域變數不是都可以被應用系統匯總任何程式檔案中的任何函式訪問

第一百七十四題 - 智能指標

174、 對于智能指標的表述，錯誤的是 ( ( ( C ) ) ) ，

建構式中計數初始化為1
拷貝建構式中計數值加1
賦值運算子中，左右兩邊的物件參考計數分別加一
解構式中參考計數減一

第一百七十五題 - 行內函式

175、 行內函式的定義，錯誤的是 ( ( ( D ) ) ) ，

行內函式要做引數型別檢查，這是行內函式跟宏相比的優勢
行內函式是指嵌入代碼，就是在呼叫函式的地方不是跳轉，而是把代碼直接寫到那里去
對于短小簡單的代碼來說，行內函式可以帶來一定的效率提升，而且和C時代的宏函式相比，行內函式更安全可靠
行內函式就是時間換空間的概念的體現

第一百七十六題 - 初始化串列

176、 關于初始化串列的表述，錯誤的是 ( ( ( D ) ) ) ，

使用初始化串列主要是基于性能問題
對于型別別來說，最好使用初始化串列
它可以直接呼叫拷貝建構式初始化，省去了一次呼叫默認建構式的程序
對于內置型別，如int, float等，使用初始化串列和在建構式體內初始化差別很大

第一百七十七題 - 庫函式

177、 以下strcpy的實作中，哪一步有問題 ( ( ( C ) ) ) ，

char * strcpy(char * strDest,const char * strSrc) {
     if ( (strDest == NULL) || (strSrc == NULL) )     // (1)                 
         return NULL;                              
     char * strDestCopy = strDest;                    // (2)
     while ((*++strDest = *++strSrc) != '\0');        // (3)
     *strDest = '\0';                                 // (4)
     return strDestCopy;
}

( 1 ) (1) (1)
( 2 ) (2) (2)
( 3 ) (3) (3)
( 4 ) (4) (4)

第一百七十八題 - 賦值運算子

178、 對于運算式int x = 6; (x += x);的值是 ( ( ( C ) ) ) ，

第一百七十九題 - 運算子

179、 對于運算式(+a + !-b **c / *d)，共有 ( ( ( D ) ) ) 個一元運算子，

第一百八十題 - 型別轉換

180、 char w; int x; float y; unsigned int z;則運算式: w * x - z + (int)y值的資料型別是 ( ( ( B ) ) ) ，

float
unsigned int
int
char

第一百八十一題 - 逗號運算式

181、 (rec1,rec2,rect3,(rec4,rec5)) - rect5;運算式最終的值是 ( ( ( D ) ) ) ，

rec1
rec2
rec4
0

第一百八十二題 - 位元組序

182、 X 定義如下，若存在 X a; a.x=0x98765432;則 a.y[2]的值可能為 ( ( ( A ) ) ) ，

union X{
    int x;
    char y[4]; 
};

0x54
0x89
0x67
0x45

第一百八十三題 - 指標

183、 對于指標的描述，正確的是 ( ( ( A ) ) ) ，

指標變數是用來存放記憶體地址的變數
不同型別的指標變數所占用的存盤單元長度不同
陣列可以進行自增操作
指標不能進行自增操作

第一百八十四題 - 補碼

184、 0 的補碼是 ( ( ( A ) ) ) ，

0b00000000000000000000000000000000
0b10000000000000000000000000000000
0b10000000000000000000000000000001
0b11111111111111111111111111111111

第一百八十五題 - 虛函式

185、 以下哪種函式可以是虛函式是 ( ( ( A ) ) ) ，

靜態成員函式
行內成員函式
建構式
普通成員函式

第一百八十六題 - 排序

186、 閱讀以下代碼，確定它實作的是 ( ( ( C ) ) ) ，


#include <stdio.h>

int a[1010];

void input(int n, int *a) {
    for(int i = 0; i < n; ++i) {
        scanf("%d", &a[i]);
    }
}

void output(int n, int *a) {
    for(int i = 0; i < n; ++i) {
        if(i)
            printf(" ");
        printf("%d", a[i]);
    }
    puts("");
}

void swap(int *a, int *b) {
    int tmp = *a;
    *a = *b;
    *b = tmp;
}

void X(int n, int *a) {              // (1)
    int i, j;
    for(i = 0; i < n - 1; ++i) {     // (2)
        int min = i;                 // (3)
        for(j = i+1; j < n; ++j) {   // (4)
            if(a[j] < a[min]) {
                min = j;             // (5)
            }
        }
        swap(&a[i], &a[min]);        // (6) 
    }
}

int main() {
    int n;
    while(scanf("%d", &n) != EOF) {
        input(n, a);
        X(n, a);
        output(n, a);
    }
    return 0;
}

冒泡排序
插入排序
選擇排序
快速排序

第一百八十七題 - 位與運算

187、 x & (1 << k)代表的是 ( ( ( C ) ) ) ，

x x x 的十進制位低位第 k k k 位的值是 0 還是 1
x x x 的十進制位高位第 k k k 位的值是 0 還是 1
x x x 的二進制位低位第 k k k 位的值是 0 還是 1
x x x 的二進制位高位第 k k k 位的值是 0 還是 1

第一百八十八題 - 位或運算

188、 1 | 2 | 3 | 4 | 5的結果為 ( ( ( D ) ) ) ，

第一百八十九題 - 異或運算

189、 1 ^ 2 ^ 3 ^ 4 ^ 5的結果為 ( ( ( D ) ) ) ，

第一百九十題 - 按位取反運算

190、 ~~-1 的結果為 ( ( ( B ) ) ) ，

0
-1
1
-2

第一百九十一題 - this

191、 下列有關 this 指標表述，正確的是 ( ( ( C ) ) ) ，

保證基類私有成員在子類中可以被訪問
保證基類保護成員在子類中可以被訪問
保證每個物件擁有自己的資料成員，但共享處理這些資料的代碼
保證基類公有成員在子類中可以被訪問

第一百九十二題 - 拷貝構造

192、 假定 C 為一個類，則該類的拷貝建構式的宣告陳述句是 ( ( ( C ) ) ) ，

C(Cx)
C&(Cx)
C(C&x)
C(C*x)

第一百九十三題 - 拷貝構造

193、 關于拷貝構造的表述，正確的是 ( ( ( C ) ) ) ，

該函式只有一個引數，是對某個物件的參考
每個類都必須有一個拷貝初始化建構式，如果類中沒有說明拷貝建構式，則編譯器系統會自動生成一個預設拷貝建構式，作為該類的保護成員
拷貝初始化建構式的作用是將一個已知物件的資料成員值拷貝給正在創建的另一個同類的物件
該函式名同類名，也是一種建構式，該函式回傳自身參考

第一百九十四題 - 虛函式

194、 有關 C++ 虛函式的概念，正確的是 ( ( ( B ) ) ) ，

解構式必須是虛函式
解構式可以是虛函式
虛函式不占用記憶體空間
建構式可以是虛函式

第一百九十五題 - 建構式

195、 有關 C++ 建構式的概念，正確的是 ( ( ( D ) ) ) ，

類不可以不定義建構式
建構式不可以是虛函式
建構式不可以沒有引數
建構式沒有回傳值

第一百九十六題 - 記憶體泄漏

196、 有關 C++ 記憶體泄漏的概念，錯誤的是 ( ( ( A ) ) ) ，

運行效率高的情況下，記憶體泄漏不是大問題
記憶體泄漏以后，程式可能還能繼續運行
為了避免記憶體泄漏，可以使用智能指標
為了避免記憶體泄漏，解構式宣告為虛函式

第一百九十七題 - 常量

197、 下列的常量定義中，錯誤的定義是 ( ( ( A ) ) ) ，

const int a = a;
const double b = 1;
const int c = 5.20f;
const float a = 0.0f;

第一百九十八題 - 函式多載

198、 已知運算式 ++a 中的 “++” 是作為成員函式多載的運算子, 則與 ++a 等效的運算子函式呼叫形式為 ( ( ( A ) ) ) ，

a.operator++()
operator++(a,1)
a.operator++(1)
a.operator++(0)

第一百九十九題 - 回圈

199、 for(int x = 2 , y = 0; y <= 5 ; y += x)陳述句執行回圈的次數是多少次？ ( ( ( A ) ) ) ，

3
4
5
無數次

第兩百題 - 回圈

200、 以下哪個 while 陳述句是死回圈 ( ( ( D ) ) ) ，

while(continue) { break; }
while(a) { int a = 5; ++a;}
int a = 1; while( a && !a) {}
int a = 10; while(1 + a * a);

🙉飯不食，水不飲，題必須刷🙉
C語言免費動漫教程，和我一起打卡！ 🌞《光天化日學C語言》🌞
LeetCode 太難？先看簡單題！ 🧡《C語言入門100例》🧡
資料結構難？不存在的！ 🌳《資料結構入門》🌳
LeetCode 太簡單？演算法學起來！ 🌌《夜深人靜寫演算法》🌌
究極演算法奧義！深度學習！ 🟣《深度學習100例》🟣

轉載請註明出處，本文鏈接：https://www.uj5u.com/ruanti/292237.html

標籤：其他

上一篇：滿天星空小游戲—小白一學就會的python游戲開發實戰【原始碼+教程】

下一篇：3年已過，你知道這些目標網站，過去是如何被爬的嗎？爬蟲100例復盤5

??三萬字《C/C++面試突擊200題》四年面試官爆肝整合??(附答案，建議收藏)

前言

文章目錄

第一題 - 遞回

第二題 - 運算子

第三題 - 字串

第四題 - 智能指標

第五題 - 解構式

第六題 - 指標

第七題 - 溢位

第八題 - 字串

第九題 - 函式

第十題 - 靜態變數

第十一題 - 函式指標

第十二題 - 三級指標

第十三題 - 強制轉換

第十四題 - 靜態變數

第十五題 - 編譯

第十六題 - 指標

第十七題 - 輸入

第十八題 - 設計模式

第十九題 - 變數

第二十題 - 進制轉換

第二十一題 - 賦值運算子

第二十二題 - 變數

第二十三題 - 全域變數

第二十四題 - 函式

第二十五題 - 整型

第二十六題 - 整型

第二十七題 - 靜態變數

第二十八題 - 運算子

第二十九題 - 運算子

第三十題 - 型別轉換

第三十一題 - 逗號運算式

第三十二題 - 位元組序

第三十三題 - 指標

第三十四題 - 補碼

第三十五題 - 類

第三十六題 - 進制轉換

第三十七題 - 位與運算

第三十八題 - 位或運算

第三十九題 - 異或運算

第四十題 - 按位取反運算

第四十一題 - 左移位運算

第四十二題 - 右移位運算

第四十三題 - 右移位運算

第四十四題 - 虛函式

第四十五題 - 建構式

第四十六題 - 記憶體泄漏

第四十七題 - 常量

第四十八題 - 建構式

第四十九題 - 回圈

第五十題 - 回圈

第五十一題 - 回圈

第五十二題 - 回圈

第五十三題 - 常量

第五十四題 - 參考

第五十五題 - 建構式

第五十六題 - 智能指標

第五十七題 - 記憶體分配

第五十八題 - 記憶體分配

第五十九題 - C++性質

第六十題 - 位與運算

第六十一題 - 位與運算

第六十二題 - 指標和參考

第六十三題 - 例外

第六十四題 - 靜態變數

第六十五題 - 編譯

第六十六題 - 指標

第六十七題 - 輸入

第六十八題 - 設計模式

第六十九題 - 變數

第七十題 - 進制轉換

第七十一題 - 賦值運算子

第七十二題 - 變數

第七十三題 - 全域變數

第七十四題 - 函式宣告

第七十五題 - 進制

第七十六題 - 進制

第七十七題 - 靜態變數