《C/C++面试200题》四年面试官精心整理

前言

  辛苦搬砖 「 十年 」 的老码农，「 四年 」 的 C/C++ 面试官经验，整理出了一些当年用来「 虐候选人 」的题（不要打我🤣🤣🤣），先弄个 「 200 」 题吧，还有 「 8800 」 题，后面有时间再搞吧。
  由于题目较多，整理的也比较仓促，如果发现哪道题目有误，可以在 「 评论区指出 」 ，我们一起完善这套试题。然后，去 「 虐更多的人 」 ？！啊？？？
  题目均为「 四选项选择题 」，用 「 鼠标/手指 」 「 反选 」 对应题目中的 「 括号 」 就能看到答案了。

🙉饭不食，水不饮，题必须刷🙉
C语言免费动漫教程，和我一起打卡！ 🌞《光天化日学C语言》🌞
LeetCode 太难？先看简单题！ 🧡《C语言入门100例》🧡
数据结构难？不存在的！ 🌳《数据结构入门》🌳
LeetCode 太简单？算法学起来！ 🌌《夜深人静写算法》🌌
究极算法奥义！深度学习！ 🟣《深度学习100例》🟣

第一题 - 递归

1、 对于以下递归函数 $f$，调用 $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 $)$ 。

• 0
• 1
• 2
• 3

---

第六题 - 指针

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

• 4,4
• 4,8
• 8,4
• 8,8

---

第七题 - 溢出

7、 执行 C++ 程序时出现的 “溢出” 错误属于 $($ D $)$ 错误。

• 编译
• 链接
• 逻辑
• 运行

---

第八题 - 字符串

8、 字符串"A+K=47\n"的长度为 $($ B $)$ 。

• 6
• 7
• 8
• 5

---

第九题 - 函数

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 $)$ 。

• 1.5
• 2.1
• 1
• 0

---

第十四题 - 静态变量

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 $)$ 。

• 30
• -60
• -24
• 144

---

第二十二题 - 变量

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 $)$ 。

• 3
• 4
• 5
• 6

---

第三十二题 - 字节序

32、 X 定义如下，若存在 X a; a.x=0x11223344;则 a.y[1]的值可能为 $($ C $)$ 。

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;
} 

• 6
• 7
• 8
• 9

---

第六十一题 - 位与运算

61、 根据以下程序，当调用 func(7777)，输出值为 $($ B $)$ 。

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

• 6
• 7
• 8
• 9

---

第六十二题 - 指针和引用

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 $)$ 。

• 9
• 55
• 64
• 0

---

第六十六题 - 指针

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^{32}-1]$
• $[-2^{31},2^{31}-1]$
• $[-2^{31},2^{31}]$

---

第七十三题 - 全局变量

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 $)$ 个一元运算符。

• 2
• 3
• 4
• 5

---

第八十题 - 类型转换

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$ 位的值为 $($ B $)$ 。

• $1^x$
• $2^x$
• $x^2$
• $x$

---

第九十二题 - 右移位运算

92、 1 右移 $x$ 位相当于 $($ A $)$ 。

• $\frac{1}{2^x}$
• $\frac{1}{2}$
• $\frac{1}{x^2}$
• $\frac{1}{x^x}$

---

第九十三题 - 右移位运算

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(4)$，其返回值为 $($ D $)$ 。

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

• 2
• 3
• 4
• 5

---

第一百零二题 - 操作符

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)为多少？ $($ B $)$ 。

• 4
• 8
• 100
• 101

---

第一百零七题 - 溢出

107、 1 加上 $2^{32}-1$ 的结果为 $($ D $)$ 。

• 0
• $2^{32}$
• $2^{31}$
• 不一定

---

第一百零八题 - 字符串

108、 字符串"A\0+K=47\n"的长度为 $($ B $)$ 。

• 10
• 1
• 2
• 6

---

第一百零九题 - 变量

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 $)$ 。

• 3
• 4
• 5
• 6

---

第一百二十二题 - 逻辑运算符

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、 给出一段代码，问程序运行后输出结果为多少？ $($ A $)$ 。

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)$ 实现的是变量交换；
• $(2)$ 默认最小的那个元下标是 $i$；
• $(3)$ 从a[i]到a[n-1]选择一个最小的数，记录下标在min中；
• $(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;
} 

• 6
• 7
• 8
• 9

---

第一百六十一题 - 位与运算

161、 根据以下程序，当调用 func(6666)，输出值为 $($ A $)$ 。

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

• 5
• 6
• 7
• 8

---

第一百六十二题 - 指针和引用

162、 有关指针和引用的说法，错误的是 $($ A $)$ 。

• 引用可以转换为指针，指针无法转换成引用
• 引用必须被初始化，指针不必
• 引用初始化以后不能被改变，指针可以改变所指的对象
• 不存在指向空值的引用，但是存在指向空值的指针

---

第一百六十三题 - 算术运算符

163、 int a = 9, b = 2, c;, 执行语句 c = a / b + 0.5;后, c的值为 $($ C $)$ 。

• 5
• 5.0
• 4
• 0

---

第一百六十四题 - 静态变量

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^{32}-1]$
• $[-2^{31},2^{31}-1]$
• $[-2^{31},2^{31}]$

---

第一百七十三题 - 全局变量

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)$
• $(2)$
• $(3)$
• $(4)$

---

第一百七十八题 - 赋值运算符

178、 对于表达式int x = 6; (x += x);的值是 $($ C $)$ 。

• 6
• 66
• 12
• 0

---

第一百七十九题 - 运算符

179、 对于表达式(+a + !-b **c / *d)，共有 $($ D $)$ 个一元运算符。

• 2
• 3
• 4
• 5

---

第一百八十题 - 类型转换

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$ 的十进制位低位第 $k$ 位的值是 0 还是 1
• $x$ 的十进制位高位第 $k$ 位的值是 0 还是 1
• $x$ 的二进制位低位第 $k$ 位的值是 0 还是 1
• $x$ 的二进制位高位第 $k$ 位的值是 0 还是 1

---

第一百八十八题 - 位或运算

188、 1 | 2 | 3 | 4 | 5的结果为 $($ D $)$ 。

• 4
• 5
• 6
• 7

---

第一百八十九题 - 异或运算

189、 1 ^ 2 ^ 3 ^ 4 ^ 5的结果为 $($ D $)$ 。

• 4
• 3
• 2
• 1

---

第一百九十题 - 按位取反运算

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例》🟣