Day01_刷题niuke20250615

单选题

C++

C语言

1.

已知int i=0, x=1, y=0;，在下列选项中，使i的值变成1的语句是（）

A

if( x&&y ) i++;

B

if( x==y ) i++;

C

if( x||y ) i++;

D

if( !x ) i++;

正确答案：C

官方解析：

要判断给定初始条件(i=0, x=1, y=0)下哪个语句能使i的值变为1,我们需要逐个分析每个选项中条件表达式的结果。

C选项 if(x||y) i++ 是正确的,因为:
- x||y 是逻辑或运算
- 当x=1,y=0时,只要有一个为真,整个表达式就为真
- 由于x=1,所以x||y的结果为真
- 因此会执行i++,使i从0变为1

分析其他选项:
A选项 if(x&&y) i++ 错误:
- x&&y是逻辑与运算
- 当x=1,y=0时,由于y为假,整个表达式为假
- 不会执行i++,i仍为0

B选项 if(x==y) i++ 错误:
- x==y判断x和y是否相等
- 当x=1,y=0时,它们不相等
- 表达式为假,不会执行i++

D选项 if(!x) i++ 错误:
- !x是逻辑非运算
- 当x=1时,!x的结果为假
- 不会执行i++,i保持为0

所以只有C选项能使i的值变为1。

知识点：C++、C语言

题友讨论(2) 

单选题

C语言

2.

关于C语言程序说法不正确的是（ ）

A

C程序由函数构成，但只有一个main()函数。

B

C程序中main()函数可以在程序的任何位置。

C

C程序由main()函数开始执行，由main()结束执行。

D

在C程序中main()函数的位置必须在程序的第一行。

正确答案：D

官方解析：

这道题目考察了C语言程序结构的基本知识。D选项错误，因为在C语言中main()函数不必须在程序的第一行。实际上，main()函数可以在源文件的任何位置定义，只要确保它在被调用之前已经声明即可。通常会在它之前放置头文件包含、宏定义、全局变量声明等。

分析其他选项：
A错误：C程序可以包含多个函数，不仅仅只有一个main()函数。main()函数是程序的入口函数，但程序中可以定义和使用其他功能函数。

B正确：C程序中main()函数确实可以在程序的任何位置定义，只要确保在编译时能够找到它即可。

C正确：main()函数是C程序的入口点和结束点。程序从main()函数开始执行，当main()函数执行完毕后，程序也就结束了。这是C语言程序执行的基本特征。

总的来说，C语言程序的结构比较灵活，虽然main()函数是必需的，但它的位置并不是固定的，可以根据程序的设计需要来安排。通常会将main()函数放在比较靠后的位置，这样可以让程序结构更清晰。

知识点：C语言

题友讨论(7) 

单选题

C++

C语言

3.

下面程序的输出为（）

1 2 3 4 5 6 7 8

int main() {     char *ptr;        char arr[] = "12345678";     ptr = arr;     ptr += 5;     printf("%s", ptr);     return 0; }

A

5678

B

678

C

编译错误

D

其它选项都不对

正确答案：B

你的答案：A

官方解析：

这道题目考察了 C 语言中字符指针和字符数组的基本操作以及字符串输出函数 printf 的使用。

程序执行分析：
1. 定义了字符数组 arr[] = "12345678"，存储了字符串 "12345678"
2. 字符指针 ptr 初始指向 arr 的首地址
3. 执行 ptr += 5 后，指针向后移动 5 个位置，指向字符 '6'
4. printf("%s", ptr) 会从指针 ptr 指向的位置开始，一直打印到遇到字符串结束符 ''

所以最终输出结果是 "678"，B 选项正确。

分析其他选项：
A 错误：输出 "5678" 需要指针只移动 4 个位置，而代码中移动了 5 个位置
C 错误：程序可以正常编译和运行，不会出现编译错误
D 错误：已经分析出程序会输出 "678"，因此其他选项都不对的说法不成立

补充说明：
这是一个典型的字符串截取示例，通过移动指针的方式可以从任意位置开始输出字符串。需要注意的是，这种操作要确保指针不会越界，且目标字符串要以 '' 结尾。

知识点：C++、C++工程师、2019、C语言

题友讨论(22) 

单选题

C++

C语言

4.

执行下面代码段

1 2 3 4

int x=-1;  do {     x=x*x;  } while (!x);

时，下列说法正确的是（）

A

循环体将执行一次

B

循环体将执行两次

C

循环体将执行无限次

D

系统将提示有语法错误

正确答案：A

官方解析：

这道题目考察了do-while循环和数值运算的执行过程。首先让我们跟踪代码的执行：

1. 初始时 x = -1
2. 第一次循环：x = x * x = (-1) * (-1) = 1
3. while条件 !x 判断：!1 为 false，循环结束

所以循环体只执行了一次，A选项正确。

分析其他选项：
B错误：循环在第一次执行后，x变为1，!x为false，不满足继续循环的条件，因此不会执行第二次。

C错误：由于第一次循环后x变为1，循环条件不满足，所以不会无限循环。

D错误：代码在语法上完全正确，不会出现语法错误。do-while循环和算术运算都符合C/C++语法规范。

关键点：
1. do-while循环至少会执行一次循环体
2. !运算符对非零值返回false，对零值返回true
3. 负数的平方是正数
4. 代码中的运算和流程控制都是合法的

所以循环只会执行一次，A是正确答案。

知识点：C++、C语言

题友讨论(13) 

单选题

C++

C语言

5.

对于下面代码段

1	const char * const name = " Chen ";

下面的语句中正确的是？
 

A

name[3]='a';

B

name="lin";

C

name=new char[5];

D

cout<<name[3];

正确答案：D

官方解析：

这道题目考察了const关键字的使用和指针的const限定。

在代码 const char * const name = " Chen "; 中:
- 第一个const表示指针指向的内容(字符)不能被修改
- 第二个const表示指针本身不能被修改指向其他地址

D选项正确:cout<
分析其他错误选项:
A错误:name[3]='a'试图修改指针指向的字符串内容,而第一个const限定了字符串内容不能被修改。

B错误:name="lin"试图让指针指向新的字符串,而第二个const限定了指针不能改变指向。

C错误:name=new char[5]同样试图改变指针的指向,这违反了第二个const的限定。

这里const char * const实际上创建了一个内容和指向都不能修改的字符串常量,只能进行读取操作。

知识点：C++、C语言

题友讨论(15) 

单选题

C语言

6.

1 2 3 4 5 6 7

int *fun(int a) { 函数体语句 }

函数fun()是一个指针函数,返回值为一个整型的指针.

说法是否正确？

A

正确

B

错误

正确答案：A

官方解析：

这道题目考察的是C语言中指针函数和函数指针的概念。A选项正确,这确实是一个指针函数。

指针函数是指返回值为指针类型的函数。题目中给出的函数fun()的声明形式为"int *fun(int a)",其中:
- int * 表示函数返回值类型是整型指针
- fun是函数名
- (int a)是函数参数

需要注意区分指针函数和函数指针的概念:
1. 指针函数:返回值为指针的函数,如本题中的fun()
2. 函数指针:指向函数的指针,声明形式为:int (*p)(int)

从语法形式上可以这样记忆:
- 指针函数:* 在函数名前面
- 函数指针:* 在括号内的函数名前面

所以原题中说法完全正确,fun()确实是一个指针函数,其返回值是指向整型的指针。这种函数常用于需要在函数外部返回指针类型数据的场景,如动态分配内存后返回内存地址等情况。

知识点：C语言

题友讨论(15) 

单选题

C语言

7.

下面关于if语句和switch语句的叙述中错误的是：

A

if语句和switch语句都可以实现算法的选择结构

B

if语句和switch语句都能实现多路选择

C

if语句可以嵌套使用

D

switch语句不能嵌套使用

正确答案：D

官方解析：

Switch语句可以嵌套使用。

知识点：C语言

题友讨论(5) 

单选题

C++

C语言

8.

下面代码段输出为（）

1 2 3 4 5 6 7 8 9 10 11

#include <stdio.h> int i; int main(){   for(i = 0;i < 3;i++){     switch(i){     case 0: printf("%d", i);     case 2: printf("%d", i);     default: printf("%d", i);     }   } }

A

000111

B

000020

C

000102

D

000122

正确答案：D

官方解析：

这道题目涉及C++中的switch-case语句和循环语句的执行流程。让我们逐步分析程序的执行过程：

1. 程序有一个for循环,i从0到2循环3次。

2. 每次循环中都有一个switch语句,但关键是这个switch语句中没有break语句,这会导致case穿透(fall-through)现象。

3. 当i=0时:
- 进入case 0,打印0
- 由于没有break,继续执行case 2,打印0
- 继续执行default,打印0
所以输出:000

4. 当i=1时:
- 不匹配case 0和case 2
- 执行default,打印1
所以输出:1

5. 当i=2时:
- 进入case 2,打印2
- 由于没有break,继续执行default,打印2
所以输出:22

6. 将以上输出连接起来就是:000122

因此D选项(000122)是正确答案。

分析其他选项：
A(000111)错误:没有考虑到case穿透效果
B(000020)错误:忽略了switch语句的case穿透特性
C(000102)错误:没有正确处理i=2时的case穿透效果

这个题目的关键是要理解switch语句中如果没有break语句,会发生case穿透,即会继续执行下一个case的内容,直到遇到break或switch结束。

知识点：C++、C++工程师、2016、C语言

题友讨论(34) 

单选题

C语言

9.

1 2	int x, a[10] = {0, 1, 2}, *p = a; x = *(p + 2);

此语句将a[2]赋值给变量x。是否正确？

A

正确

B

错误

正确答案：A

官方解析：

该题目考察指针运算的基本概念。这段代码是正确的,*(p + 2)确实会得到a[2]的值。

具体分析:
1. 数组a被初始化为{0,1,2},后面的元素默认为0
2. 指针p被初始化指向数组a的首地址,即p = &a[0]
3. p + 2表示指针向后偏移2个位置,指向a[2]
4. *(p + 2)表示取p+2所指向位置的值,即a[2]的值2
5. 最终x = *(p + 2)就是将2赋值给变量x

这里涉及到两个重要的指针概念:
- 指针算术运算:p + n 表示指针向后移动n个元素的位置
- 指针解引用:*操作符用于获取指针所指向地址的值

所以A选项"正确"是对的,这个语句确实能够实现将a[2]的值赋给变量x。

事实上,在C/C++中,a[i]和*(a + i)是等价的表达式,都表示访问数组中下标为i的元素。这也是为什么指针和数组经常可以互换使用的原因。

知识点：C语言

题友讨论(8) 

单选题

C++

C语言

10.

下面字符常量正确的是（ ）

A

“c”

B

‘\\’’

C

‘n’

D

‘ab’

正确答案：C

官方解析：

字符常量由单引号括起来的一个字符组成。'n'是一个单独的字符,完全符合字符常量的定义,因此C选项是正确的。

分析其他选项:
A错误:"c"使用了双引号,这是字符串常量的表示方法,而不是字符常量。字符常量必须使用单引号。

B错误:'\''虽然使用了单引号,但实际上包含了多个字符。'\'是转义字符,后面跟着一个单引号,这种写法不符合字符常量必须是单个字符的规则。

D错误:'ab'包含了两个字符,而字符常量只能包含一个字符。

需要注意字符常量的以下特点:
1. 必须使用单引号
2. 只能包含一个字符
3. 可以是普通字符、转义字符或ASCII码值对应的字符
4. 在内存中占用2个字节(在Java中)

知识点：C++、C语言

题友讨论(7) 

单选题

C语言

11.

若要以写方式打开当前目录下文件 abc.txt，则以下语句正确的是（）。

A

fopen("abc.txt","r");

B

fopen("abc.txt","w");

C

fopen("abc.txt",'r');

D

fopen("abc.txt",'w’);

正确答案：B

官方解析：

在C语言中使用fopen()函数打开文件时，第二个参数表示文件的打开模式，需要使用字符串形式而不是字符形式。题目要求以写方式打开文件，因此应该使用"w"模式。

B选项 fopen("abc.txt","w") 是正确的，因为：
1. 文件路径"abc.txt"正确指定了当前目录下的文件
2. 打开模式"w"使用了字符串形式
3. "w"表示写入模式，会创建新文件（如果文件不存在）或截断已存在的文件

分析其他选项：
A错误：使用"r"表示只读模式，不符合题目要求的写入方式
C错误：使用字符'r'而不是字符串"r"作为模式参数，这是错误的参数类型
D错误：使用字符'w'而不是字符串"w"作为模式参数，这是错误的参数类型

补充说明：fopen()函数的模式参数必须是字符串类型，常见的模式有：
- "r"：只读模式
- "w"：写入模式
- "a"：追加模式
- "r+"：读写模式
- "w+"：读写模式（覆盖）
- "a+"：读写模式（追加）

知识点：C语言

题友讨论(15) 

单选题

C++

C语言

12.

以下程序的输出结果是(   )？

1 2 3 4 5 6 7 8

int main() {     int i, j, k, a = 3, b = 2;     i = (--a == b++) ? --a : ++b;     j = a++;     k = b;     printf("i=%d,j=%d,k=%d\n", i, j, k);     return 0; }

A

i=2,j=1,k=3

B

i=1,j=1,k=2

C

i=4,j=2,k=4

D

i=1,j=1,k=3

正确答案：D

官方解析：

让我们按照程序执行的顺序逐步分析:

1. 初始状态:
a = 3, b = 2

2. 第一个表达式 i = (--a == b++) ? --a : ++b
- 首先执行--a, a变为2
- 同时b++是后缀自增,比较时b仍为2,比较完后b变为3
- 所以--a == b++的结果是true(2 == 2)
- 因为结果为true,执行--a,此时a变为1
- 所以i = 1

3. j = a++
- 这是后缀自增,所以j获取a当前的值1
- 然后a增加到2

4. k = b
- 此时b已经是3了(之前的b++已经生效)
- 所以k = 3

5. 最终结果:
i = 1
j = 1
k = 3

所以D选项(i=1,j=1,k=3)是正确答案。

分析其他选项:
A(i=2,j=1,k=3)错误:没有正确理解三目运算符的执行顺序
B(i=1,j=1,k=2)错误:忽略了b++的效果
C(i=4,j=2,k=4)错误:完全误解了运算过程

这道题目主要考察:
1. 前缀和后缀自增/自减运算符的运算顺序
2. 三目运算符的执行机制
3. 表达式的求值顺序

知识点：C++、C语言

题友讨论(17) 

单选题

C++

C语言

13.

以下哪项不属于STL container（）

A

stack

B

queue

C

multimap

D

string

正确答案：D

官方解析：

string虽然在C++中经常使用，但它实际上属于STL的字符串类(basic_string)，不是STL容器。STL容器主要用于存储和管理各种类型的数据集合。

分析其他选项：
A. stack(栈)是STL的容器适配器，它封装了deque或list容器，提供了LIFO(后进先出)的数据结构
B. queue(队列)也是STL的容器适配器，它封装了deque容器，提供了FIFO(先进先出)的数据结构
C. multimap是STL的关联容器，允许键值重复的键值对存储

STL容器可以分为以下几类：
1. 序列容器：vector、list、deque
2. 关联容器：set、multiset、map、multimap
3. 容器适配器：stack、queue、priority_queue

虽然string在使用方式上与容器类似，但它主要目的是处理字符串，提供了字符串相关的特定操作，如字符串拼接、查找、替换等功能，因此它不属于STL容器家族。

知识点：C++、C++工程师、2016、C语言

题友讨论(18) 

单选题

C++

C语言

14.

下面程序执行后输出结果为（）

1 2 3 4 5 6 7 8

#include <stdio.h> int main() {      int i, j, m=6,n=4,  *p=&n, *q=&m;     i=p==&m;     j=(-*p)/(*q)+7;     printf("i=%d,j=%d\n", i,j);     return 0; }

A

编译错误

B

i=0,j=7

C

i=0,j=0

D

其他几项都不对

正确答案：B

官方解析：

这道题目考察了C语言中的指针比较和运算符优先级。让我们逐行分析代码：

1. 首先定义了变量 i、j、m=6、n=4，以及两个指针 p 指向 n，q 指向 m。

2. `i=p==&m` 这行代码比较指针 p 是否等于 m 的地址。由于 p 指向 n，所以 p 与 &m 不相等，因此 i 的值为 0。

3. `j=(-*p)/(*q)+7` 这行代码计算 j 的值：
- *p 的值是 4 (n 的值)
- -*p 的值是 -4
- *q 的值是 6 (m 的值)
- (-4)/6 = 0 (整数除法)
- 0 + 7 = 7
所以 j 的值为 7

4. 最终输出 `i=0,j=7`，与选项 B 完全符合。

分析其他选项：
A错误：程序可以正常编译和运行，不会出现编译错误
C错误：j 的值计算结果是 7，不是 0
D错误：B 选项已经是正确答案，其他选项都不正确

这个程序主要考察了：
- 指针的基本操作和比较
- 算术运算符的优先级
- 整数除法的运算规则
- 表达式求值过程

知识点：C++、2018、C语言

题友讨论(15) 

单选题

C++

C语言

15.

假设i=2，执行下列语句后i的值为（）

1 2 3 4 5 6 7 8

switch( i ) { case 1 : i ++; case 2 : i --; case 3 : ++ i; break; case 4 : -- i; default : i ++; }

A

1

B

2

C

3

D

4

正确答案：B

官方解析：

要理解这道题目,我们需要分析switch语句的执行流程:

1. 当i=2时,程序会直接跳转到case 2开始执行
2. 由于没有break语句,会发生case穿透现象,继续往下执行后续case
3. 具体执行过程:
- case 2执行: i-- (2减1变成1)
- case 3执行: ++i (1加1变成2)
- 遇到break跳出switch语句

所以最终i的值为2,B选项正确。

分析其他选项:
A选项(1)错误:虽然执行了i--操作使i变为1,但后续还有++i操作
C选项(3)错误:虽然有++i操作,但是这是最后一步操作,结果是2
D选项(4)错误:case 4根本没有执行到,因为在case 3时就break了

这道题的关键是要理解switch的case穿透特性:如果case后面没有break语句,则程序会继续执行下一个case的内容,直到遇到break或switch结束。这也是为什么即使我们输入的是2,case 3中的代码也会被执行。

知识点：C++、C语言

题友讨论(19) 

单选题

C语言

16.

以下代码在64位的机子上输出是（）

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

#include <stdio.h> int getSize(int data[]){     return sizeof(data); } int main(){     int data1[] = {1,2,3,4,5};     int size1 = sizeof(data1);           int* data2 = data1;     int size2 = sizeof(data2);           int size3 = getSize(data1);           printf("%d, %d, %d", size1, size2, size3);     return 0; }

A

20,8, 8

B

4, 4, 4

C

20, 4, 20

D

20, 20, 20

正确答案：A

官方解析：

这道题目考察了C语言中数组、指针的内存分配以及函数参数传递的机制。在64位系统中，size1、size2和size3的值分别是20、8、8，所以A选项正确。

让我们逐个分析这些值：

1. size1 = sizeof(data1)
- data1是一个包含5个int元素的数组
- 在64位系统中，int类型占4字节
- 所以 sizeof(data1) = 4 × 5 = 20字节

2. size2 = sizeof(data2)
- data2是一个指针变量
- 在64位系统中，指针类型统一占8字节
- 所以 sizeof(data2) = 8字节

3. size3 = getSize(data1)
- 当数组作为函数参数传递时，会退化为指针
- 函数内的参数data实际上是一个指针
- 所以 sizeof(data) = 8字节（指针大小）

其他选项错误原因：
B选项（4, 4, 4）：错误地认为所有大小都是4字节
C选项（20, 4, 20）：错误地认为指针是4字节且函数参数保持数组特性
D选项（20, 20, 20）：没有理解数组作为函数参数时会退化为指针

这个题目的关键是要理解：
1. 数组名在大多数情况下会退化为指针
2. 在64位系统中指针大小是8字节
3. 数组作为函数参数传递时会退化为指针

知识点：Java工程师、C++工程师、iOS工程师、安卓工程师、运维工程师、前端工程师、算法工程师、PHP工程师、2018、C语言

题友讨论(7) 

单选题

C++

C语言

17.

以下程序

1 2 3 4 5 6 7 8 9 10 11

#include <stdio.h> void fun(char **p) {     int i;     for (i = 0; i < 4; i++)         printf("%s", p[i]); } main() {     char *s[6] = {"ABCD", "EFGH", "IJKL", "MNOP", "QRST", "UVWX"};     fun(s);     printf("\n"); }

程序运行后的输出结果是?

A

ABCDEFGHIJKL

B

ABCD

C

AEIM

D

ABCDEFGHIJKLMNOP

正确答案：D

官方解析：

这道题目考察了C语言中字符串数组和指针的概念。

让我们分析代码的执行过程：
1. 程序定义了一个字符串数组s，包含6个字符串常量："ABCD"、"EFGH"、"IJKL"、"MNOP"、"QRST"、"UVWX"
2. fun函数接收一个字符指针数组作为参数
3. 在fun函数中，通过循环遍历前4个字符串并打印输出（i<4）
4. 每个字符串通过%s格式化输出，会打印完整的字符串内容

所以输出结果会是前4个字符串的连接：ABCDEFGHIJKLMNOP

D选项正确，因为它完整展示了程序的输出结果：前4个字符串的连接。

分析其他选项的错误原因：
A错误：只输出了前3个字符串（ABCDEFGHIJKL），漏掉了第4个字符串MNOP
B错误：只输出了第一个字符串（ABCD）
C错误：误解了输出方式，AEIM是取每个字符串的第一个字符，而实际上程序是完整输出每个字符串

这个程序的关键在于理解：
1. 字符串数组s中每个元素是一个指向字符串的指针
2. printf("%s")会从指针指向的位置开始，打印直到遇到''为止
3. 循环次数是4次，所以只会输出前4个字符串

知识点：C++、C语言

题友讨论(39) 

单选题

C++

C语言

18.

对于类Value，下面运算符重载的写法错误的是（）

A

Value operator-(Value, Value)

B

Value operator+(Value)

C

Value operator*(int)

D

Value operator/(Value)

正确答案：A

官方解析：

这道题目考察了C++中运算符重载的基本语法规则。A选项中Value operator-(Value, Value)的写法是错误的,因为作为类的成员函数进行运算符重载时,只能有一个参数。

分析各个选项:
A. Value operator-(Value, Value) 错误。双目运算符作为成员函数重载时,左操作数隐含为this指针,所以只需要一个参数。正确写法应该是Value operator-(Value)。

B. Value operator+() 正确。这是一个一元运算符重载,表示正号运算符重载。

C. Value operator*(int) 正确。这是乘法运算符重载,参数为int类型。

D. Value operator/(Value) 正确。这是除法运算符重载,参数为Value类型。

如果需要使用双参数的运算符重载,应该定义为友元函数或全局函数,写法为:
friend Value operator-(const Value&, const Value&)
或
Value operator-(const Value&, const Value&)

所以A选项的写法作为成员函数的运算符重载是错误的。

知识点：C++、C语言

题友讨论(14) 

单选题

C语言

19.

两个指针变量（ ）无意义

A

相加

B

比较

C

相减

D

指向同一地址

正确答案：A

官方解析：

指针变量是存储内存地址的变量,两个指针变量相加运算在逻辑上是没有实际意义的,因为两个内存地址相加得到的结果并不能表示一个有效的内存位置。

分析各选项:
A正确:两个指针相加得到的结果是两个内存地址的和,这个值作为地址是没有实际意义的。

B错误:两个指针变量进行比较是有意义的,可以判断它们是否指向同一内存位置,或者判断在内存中的先后位置关系。

C错误:指针相减运算是有意义的,可以得到两个指针指向位置之间的偏移量,在数组操作中经常使用。

D错误:两个指针指向同一地址是完全有意义的情况,表示它们引用同一个内存位置,这在实际编程中很常见。

总的来说,在所有指针运算中,只有相加操作是确实没有实际意义的,其他的指针操作都有其具体的应用场景。

知识点：C语言

题友讨论(23) 

单选题

C语言

20.

阅读以下程序，当输入数据的形式为25,13,10↙，正确的输出结果为（）

1 2 3 4 5

int main() {     int x, y, z；     scanf("%d%d%d", &x, &y, &z);     printf ("x+y+z=%d\n", x+y+z)； }

A

x+y+z=48

B

x+y+z=38

C

x+y+z=35

D

无法确定

正确答案：D

官方解析：

【解释】当一次scanf调用需要输入多个数据项时，如果前面数据的输入遇到非法字

符，并且输入的非法字符不是格式控制字符串中的常规字符，那么，这种非法输入将影响

后面数据的输入，导致数据输入失败。当输入为25,13,10时，a的值是25，y和z的值将

无法预测，所以x+y+z的值是无法确定的。故正确答案是D。

知识点：C语言

题友讨论(28) 

单选题

C语言

21.

turbo c环境下，下面程序运行的结果是()

1 2 3 4 5 6 7 8 9 10 11

#include <stdio.h> int main() {     printf("\n");     int a[5] = {1, 2, 3, 4, 5};     int *p, **k;     p = a;     k = &p;     printf("%d", *(p++));     printf("%d", **k);     return (0); }

A

11

B

21

C

22

D

12

正确答案：D

官方解析：

这道题目主要考察了指针运算、自增运算符以及多级指针的知识点。让我们逐步分析代码执行过程：

1. 首先定义了一个数组a[5] = {1, 2, 3, 4, 5}
2. 指针p指向数组a的首地址，即p指向元素1
3. k是二级指针，指向指针p的地址
4. printf("%d", *(p++))：
- *(p++)表示先取值后自增
- 输出p指向的值1
- p自增后指向下一个元素2
5. printf("%d", **k)：
- k指向p，所以*k得到p
- p此时已经指向2，所以**k等于2
6. 因此最终输出为12

为什么其他选项错误：
A选项(11)：错误，因为第二个输出是2而不是1
B选项(21)：错误，因为第一个输出是1而不是2
C选项(22)：错误，因为第一个输出是1而不是2

关键点在于理解后缀自增运算符p++的特点：先使用值，再进行自增操作。这导致第一个printf输出1，而第二个printf输出2，因为此时p已经指向了数组的第二个元素。

知识点：C语言

题友讨论(56) 

单选题

C++

C语言

22.

设已定义浮点型变量data，以二进制代码方式把data的值写入输出文件流对象outfile中，正确的语句是（）

A

outfile.write((double ) &data, sizeof(double));

B

outfile.write((double ) &data, data);

C

outfile.write((char *) &data, sizeof(double));

D

outfile.write((char *) &data, data);

正确答案：C

你的答案：B

官方解析：

C选项正确,因为write()方法需要两个参数:第一个参数是char*类型的指针,指向要写入的数据;第二个参数是要写入的字节数。这里需要把data转换为char*类型的指针,并写入sizeof(double)个字节。

分析其他选项:

A错误:第一个参数类型错误,不能将&data直接转换为double类型,而应该转换为char*类型的指针。

B错误:有两个问题:
1. 第一个参数类型错误,同A
2. 第二个参数使用data作为写入的字节数是不对的,应该使用sizeof(double)

D错误:虽然第一个参数类型正确,但第二个参数使用data作为写入的字节数是错误的,应该使用sizeof(double)。

这里涉及到C++文件操作的知识点:
1. write()方法的第一个参数必须是char*类型
2. 写入二进制数据时需要进行类型转换
3. 写入的字节数要使用sizeof运算符来确定
4. 不能用变量的值作为写入的字节数

因此C选项正确地完成了这两个要求,是唯一正确的写法。

知识点：C++、C语言

题友讨论(11) 

单选题

C语言

23.

已知函数的调用形式：

1	fread(buffer, size, count, fp);

，其中buffer代表的是（）

A

一个整数，代表要读入的数据项总数

B

一个文件指针，指向要读的文件

C

一个指针，指向要读入数据的存放地址

D

一个存储区，存放要读的数据项

正确答案：C

你的答案：B

官方解析：

【解释】fread函数的功能就是从fp所代表的文件中读取count*size个字节的数据存放

到指针buffer所指向的内存块中。故选择答案是C。

知识点：C语言

题友讨论(11) 

单选题

C语言

24.

下列描述，错误的是：

A

文件系统IO自带缓冲，以减小对磁盘文件的访问，提高系统性能

B

通过select和epoll能同时监听处理多个IO事件

C

使用linuxIPC中的pipe机制，生产者写入数据到消费者消费数据，依次要经过如下拷贝：生产者用户空间到生产者内核空间的拷贝，生产者内核空间到消费者内核空间的拷贝，消费者内核空间到消费者用户空间的拷贝。

D

C标准IO库自带缓冲，以减小fread或fwrite等带来的系统开销

正确答案：C

官方解析：

题目考察了操作系统中IO缓冲和进程间通信的相关知识。C选项有错误,因为在Linux的pipe机制中,并不需要从生产者内核空间到消费者内核空间的拷贝过程。pipe是在内核中开辟一块缓冲区,生产者和消费者共享这块内核缓冲区,所以只需要两次拷贝:
1. 生产者用户空间到内核缓冲区的拷贝
2. 内核缓冲区到消费者用户空间的拷贝

分析其他选项:
A正确:文件系统确实有缓冲机制,这可以减少实际的磁盘IO次数,提高性能。

B正确:select和epoll都是IO多路复用的机制,可以同时监听多个文件描述符的IO事件,实现并发处理。

D正确:C标准库的stdio.h提供了缓冲IO功能,通过缓冲区减少实际的系统调用次数,提高性能。比如fread/fwrite会先写入缓冲区,当缓冲区满时才进行实际的系统调用。

知识点：Java工程师、C++工程师、2017、测试工程师、C语言

题友讨论(7) 

单选题

C语言

25.

在64位操作系统上，下面程序返回结果是（）

1 2 3 4 5

int main() {     int *k[10][30];     printf("%d\n", sizeof(k));     return 0; }

A

4

B

8

C

1200

D

2400

正确答案：D

你的答案：B

官方解析：

这道题目考察了C语言中指针数组的内存大小计算。

在64位系统中:
1. k是一个二维数组，维度为[10][30]
2. 数组的每个元素都是int类型的指针
3. 在64位系统中,指针的大小是8字节
4. 所以总大小 = 10 × 30 × 8 = 2400字节

因此D选项2400是正确答案。

分析其他选项:
A选项(4):错误。4是32位系统中一个int的大小,而题目明确说明是64位系统下的指针大小。

B选项(8):错误。8仅仅是64位系统中一个指针的大小,而不是整个数组的大小。

C选项(1200):错误。这个结果可能是把指针大小算成了4字节(32位系统),计算方式为10×30×4=1200,但题目明确是64位系统。

注意事项:
- 指针数组k[10][30]表示有300个元素的数组
- 每个元素都是int*类型
- 在64位系统中每个指针占8字节
- 所以总大小就是300×8=2400字节

知识点：C语言

题友讨论(9) 

单选题

数组

字符串

C语言

C++

26.

在 C/C++ 中，若有定义 char a [10], *p=a; ，那么下列赋值语句正确的是( )。

A

a [] ="abcdefg";

B

a="abedefg";

C

*p="abcdefg";

D

p="abcdefg ";

正确答案：D

你的答案：C

官方解析：

这道题目考察了C/C++中指针和数组的基础知识。

首先需要理解题目给出的定义: char a[10]声明了一个长度为10的字符数组，*p=a将数组a的首地址赋给指针p。

选项D是正确的，因为此时p已经是一个指针，可以接受新的地址赋值。"abcdefg"是一个字符串常量，它的值是该字符串存储位置的首地址，可以直接赋值给指针p。

分析其他错误选项：

A错误：a[]不是合法的数组表示方式。正确的数组赋值应该是strcpy(a, "abcdefg")或者在定义时初始化。

B错误：数组名a代表数组的首地址，是常量，不能作为左值进行赋值操作。这种写法试图将一个地址赋值给一个常量，这是非法的。

C错误：*p="abcdefg"试图将一个字符串的地址赋值给一个字符，这是类型不匹配的。*p只能接受单个字符的赋值，如*p='a'。

总的来说，这道题主要是考察对数组名、指针以及字符串常量本质的理解。

知识点：C++、数组、字符串、C语言

题友讨论(86) 

单选题

C语言

27.

下述程序有什么问题？

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

#include   <string.h> #include   <stdio.h>  #include   <stdlib.h>  void getmemory(char*p)  {         p=(char *) malloc(100);         strcpy(p,"hello world");   }   int main( )  {         char *str=NULL;         getmemory(str);         printf("%s\n",str);        free(str);         return 0;     }

A

正常输出'hello world"

B

错误的操作

C

输出"烫烫烫"

D

程序崩溃

正确答案：B

你的答案：D

官方解析：

这道题目考察了C语言中指针和内存管理的基本概念。程序存在严重的内存操作错误。

主要问题在于getmemory函数中的参数传递方式。在C语言中，函数参数是值传递，getmemory函数中的p是str的一个副本，而不是str本身。虽然在getmemory函数内部为p分配了内存并赋值，但这些操作都是在p的副本上进行的，函数返回后这些改变不会影响到main函数中的str。因此str仍然是NULL。

具体分析：
1. getmemory函数执行后，main函数中的str依然是NULL
2. printf尝试打印NULL指针指向的内容，这是未定义行为
3. free(str)试图释放一个NULL指针，这也是错误的操作

分析其他选项：
A错误：不会输出"hello world"，因为str仍然是NULL
C错误：不会输出"烫烫烫"，因为str是NULL
D错误：虽然程序可能会崩溃，但题目主要考察的是内存操作的错误性

要修正这个问题，应该将getmemory函数改为传递指针的指针：void getmemory(char **p)，或者返回分配的内存地址。这样才能真正修改main函数中str的值。

知识点：C语言

题友讨论(114) 

多选题

C++

C语言

28.

下面对一维数组 a 进行正确的初始化的语句是（）

A

int a[10] = (0, 0, 0, 0, 0); //注:这里是小括号

B

int a[10] = {};

C

int a[10] = {10};

D

int a[10] = {10, 0, -1};

正确答案：BCD

官方解析：

数组初始化是C语言中的重要知识点。让我们逐个分析各选项:

B正确: int a[10] = {}; 是合法的初始化方式。这种写法会将数组的所有元素初始化为0。在C语言中,当初始化列表为空时,编译器会自动将所有元素设置为0。

C正确: int a[10] = {10}; 这种写法会将数组的第一个元素初始化为10,其余元素自动初始化为0。这是因为当初始化列表中的元素个数少于数组长度时,剩余元素会被自动初始化为0。

D正确: int a[10] = {10, 0, -1}; 这种写法会将数组的前三个元素分别初始化为10、0、-1,其余元素自动初始化为0。同样符合上述规则。

A错误: int a[10] = (0, 0, 0, 0, 0); 这种写法是错误的,因为:
1. 数组初始化必须使用花括号{},而不是圆括号()
2. 圆括号()在C语言中表示逗号表达式,其结果是最后一个表达式的值,而不是用来初始化数组的

总之,数组初始化时要注意:
1. 必须使用花括号{}
2. 初始化列表可以为空
3. 当初始化列表中元素个数少于数组长度时,剩余元素会被自动初始化为0

知识点：C++、C语言

题友讨论(84) 

多选题

C语言

29.

以下对C语言函数的有关描述中，正确的有（）

A

在C程序中，函数调用不能出现在表达式语句中

B

在C语言中，一个函数一般由两个部分组成，它们是函数首部和函数体

C

函数的实参和形参可以是相同的名字

D

在main()中定义的变量都可以在其它被调函数中直接使用

E

外部类型的变量只能定义一次，但可在不同地方声明多次

正确答案：BCE

你的答案：BC

官方解析：

让我们逐个分析每个选项:

B正确:函数确实由函数首部(包含函数名、返回值类型、参数列表)和函数体(由{}括起来的代码块)两个部分组成,这是C语言函数的基本结构。

C正确:实参和形参可以使用相同的名字,因为它们属于不同的作用域。形参是函数内的局部变量,与函数外的同名变量不会产生冲突。

E正确:外部变量(使用extern关键字声明的变量)在整个程序中只能定义一次,但可以在需要使用的地方多次声明,这是为了让编译器知道该变量的存在。

分析错误选项:

A错误:函数调用是可以出现在表达式中的,比如:z = max(x,y) + 1;这样的表达式是完全合法的。

D错误:main()函数中定义的局部变量只在main()函数内有效,其他函数不能直接访问。这涉及到变量作用域的概念,局部变量的作用域仅限于定义它的函数内部。如果要在其他函数中使用main()中的变量,需要通过参数传递或使用全局变量。

总的来说,这道题目主要考察了C语言中关于函数定义、变量作用域、参数传递以及外部变量等基本概念。

知识点：2015、C++工程师、C语言

题友讨论(10) 

多选题

C++

C语言

30.

1 2 3 4

#include<stdio.h> int c[3][4]; int (*p)[4]; p=c;

以下能够获取c[1][3]值的是（）

A

*(*(p+1)+3)

B

*((int *)p+7)

C

*(p[1]+3)

D

*(p+1)+3

正确答案：ABC

官方解析：

这道题目考察指针的基础知识，特别是数组指针的使用。

分析每个选项：

A. *(*(p+1)+3) 正确。
p是指向整型数组的指针，p+1指向第二行，*(p+1)得到第二行首地址，再+3移动到第4个元素，最后解引用得到c[1][3]的值。

B. *((int *)p+7) 正确。
将p强制转换为int型指针后，+7相当于向后移动7个int单位，正好到达c[1][3]的位置(因为4*1+3=7)，然后解引用。

C. *(p[1]+3) 正确。
p[1]等价于*(p+1)，表示第二行首地址，+3后移动到第4个元素，解引用得到c[1][3]。

D. *(p+1)+3 错误。
*(p+1)得到第二行首地址，但是没有最后的解引用操作，+3只是地址的算术运算，得到的结果是一个地址值而不是数组元素的值。

总结：此题主要考察了多种等价的指针表达方式。A、B、C三种写法虽然形式不同，但都能正确获取到c[1][3]的值。其中：
- A使用了典型的数组指针访问方式
- B使用了指针强制类型转换
- C使用了数组下标方式
而D选项缺少了最后的解引用操作，所以不能得到数组元素的值。

知识点：C++、2019、C语言