1.以下程序输出结果是()
cpp
int main() {
int a = 1, b = 2, c = 2, t;
while (a < b < c) {
t = a;
a = b;
b = t;
c--;
}
printf("%d %d %d", a, b, c);
}解析:a=1 b=2 c=2 a<b 成立 ,等于一个真值1 1<2 执行循环体 t被赋值为1 a被赋值2 b赋值1 c-- c变成1
a<b 不成立 则等于0 然后 0<c 成立 执行循环体 t被赋值为2 a赋值为1 b赋值为2 c-- c变成0
最后输入 1 2 0
2.以下程序输出结果是()
cpp
int main() {
char a[] = "morming", t;
int i, j = 0;
for (i = 1; i < 7; i++)
if (a[j] < a[i])
j = i;
t = a[j];
a[j] = a[7];
a[7] = a[j];
puts(a);
}解析:循环一开始循环时 a[0]<a[1] 成立 j赋值为1 又 a[1]<a[2] j又赋值为2 然后if语句不执行 一直循环到i=7
将a[7] "\0" 和 a[2] 交换位置 最后输出mo
3.以下程序输出结果是()
cpp
int main() {
char ch[2][5] = { "693","825" }, * p[2];
int i, j, s = 0;
for (i = 0; i < 2; i++) p[i] = ch[i];
for (i = 0; i < 2; i++)
for (j = 0; p[i][j] < '0' && p[i][j] <= '9'; j += 2)
s = 10 * s + p[i][j] - '0';
printf("%d", s);
}由于"693"和"825"中的数字字符按照题目要求的规则转换并累加，得到的最终结果是6385。因此，程序的输出结果是6385。这个过程可以通过以下计算步骤详细说明：
首先处理"693"，取"6"和"3"，转换为数值后累加到
s上，得到63。然后处理"825"，取"8"和"5"，转换为数值后累加到
s上，由于之前s的值为63，所以最终累加到
s上的值是85，因此最终s的值为6385
4.以下程序输出结果是()
cpp
#define P 3
#define S(a) P*a*a
int main() {
int ar;
ar = S(3 + 5);
printf("%d", ar);
}
5.以下程序输出结果是()
cpp
#define N 3
#define Y(n) ((N+1)*n)
int main() {
int z;
z = 2 * (N + Y(5 + 1));
printf("%d", z);
}define 产量首先被替换 N被替换成3 Y（n）==》(3+1)*n)
然后我们看z = 2 * (N + Y(5 + 1)) 是怎么计算的？
N被替换成3 然后 Y（5+1） 是整体把n替换 所以z = 2*（3+(3+1)*5+1）=48 注意括号和乘法是优先计算的
6.以下程序输出结果是()
cpp
int main() {
int a = 2, b = -1, c = 2;
if (a < b)
if (b < 0) c = 0;
else c++;
printf("%d", c);
}我们来看一下该代码输出什么？ 3？ 还是 2？
答案是2，为什么呢。在if分支语句中，但if没有加{ }时，后面只能执行一条语句；else会跟随他最近的if语句（第二个if）； 因为a不小于b 则第二个if不执行 else也不执行 输出还是c=2没有变化
cpp
#define SQR(X) X*X
main() { int a=16, k=2, m=1;
a/=SQR(k+m)/SQR(k+m);
printf("%d\n",a); }先做宏替换，把语句中的SQR(x)替换为x*x，特别注意，简单替换，不添加任何括号，替换后为：
main() { int a=16, k=2, m=1;
a/=k+m*k+m/k+m*k+m;
printf("%d\n",a); }
现在我们来计算a值语句替换所有变量为数值：
a /= 2+1*2+1/2+1*2+1;
a /= 2+2+0+2+1;
a/=7;
除法之前a值16，而16/7=2，因此执行后a值是2，程序输出结果是2
8.执行以下语句，输出结果是 C 。
cpp
int x=2;
printf("%d", ((x=4*5, x*5), x+20));
A) 120 B) 100 C) 40 D) 20逗号表达式，就是用逗号隔开的多个表达式。
逗号表达式，从左向右依次执行。整个表达式的结果是最后⼀个表达式的结果 (不是一上来看最后一个,前面的表达式要依次左往右计算,再取最后的结果)
解析：先从左往右计算，x被赋值20 ，然后取最后的结果 20+20=40
以下程序的输出结果是( )。
cpp
int main() {
char*s="12134211"；
int v[4]=0，0，0，0)，k，i；
for(k=0；s[k]；k++)
switch(s[k])
case'1':i=0；
case'2':i=1；
case'3':i=2；
case'4':i=3；
v[i]++：
for(k=0；k＜4；k++)printf("%d"，v[k])；
}A．4 2 1 1B．0 0 0 8C．4 6 7 8D．8 8 8 8
本题考查switch，case语句，当k=0时，循环体成立，执行switch后表达式的值为'1'，执行case'1'，i的值为0，因为没有break语句，继续执行其后的语句，到最后一个语句时i的值为3，此时v[i]++，v[3]=1，接着执行k++后，k的值为1，当k=1时，循环成立，执行switch后的表达式的值为'2'，执行case'2'，i的值为1，因为没有break语句，继续执行其后的语句，到最后一个语句时，i的值为3，此时v[i]++，v[3]=2，接着执行k++后，k的值为2，依次下去，csse'4'也会执行，最后i的值一定为3，到v[3]=8时循环结束，而v[0]～v[2]的值一直没有变化，故选择B选项
cpp
int w = 3;
int main() {
int w = 10;
printf("%d\n", fun(5) * w);
}
fun(int k)
{
if (k == 0)
return w;
return(fun(k - 1) * k);
}
局部变量
w的作用：
- 在
main函数中，局部变量w被定义为10，遮蔽了全局变量w（值为3）。函数
fun的定义：
fun函数使用全局变量w。在函数fun的内部，变量w指的是全局变量w，即3，而不是main函数中的局部变量w。函数
fun的执行逻辑：
fun(5)调用会递归地计算fun(4) * 5，fun(4)计算fun(3) * 4，依此类推，直到fun(0)。fun(0)返回w，即3。因此，递归调用的计算过程是fun(0)返回3，然后fun(1)返回3 * 1 = 3，fun(2)返回3 * 2 = 6，fun(3)返回6 * 3 = 18，fun(4)返回18 * 4 = 72，fun(5)返回72 * 5 = 360。最终的输出：
fun(5)返回360，main函数中计算fun(5) * w为360 * 10 = 3600。
cpp
int main() {
int x = 023;
printf("%d", --x);
}023 是八进制 转成 十进制对应是 2*8^1+3*8^0=19 --x 则输出18
cpp
int a[3][3] = { {2},{4},{6} };
int main() {
int i, * p = &a[0][0];
for (i = 0; i < 2; i++) {
if (i == 0)
a[i][i + 1] = *p + 1;
else
++p;
printf("%d", *p);
}
}一开始将 数组a[0][0]的值2赋值给指针p i=0时 不影响p i=1时++p ;所以最后输出23
cpp
fun(int x)
{
static int a = 3;
a += x;
return(a);
}
int main() {
int k = 2, m = 1, n;
n = fun(k);
n = fun(m);
printf("%d", n);
}要注意静态变量a 它的值是等程序结束时才收回,所以a的值一直会保存知道程序结束;所以
一开始a = 5 然后 a变成6 最后返回 所以n=6
cpp
f(int a)
{
int b = 0; static c = 3;
a = c++, b++;
return(a);
}
int main() {
int a = 2, i, k;
for (i = 0; i < 2; i++)
k = f(a++);
printf("%d", k);
}这个题目太多干扰的变量,直接看c就行 c是静态变量,跳出函数不会收回他的值,一开始a = c++
先赋值 后加一 然后调用两次函数 第一次 a的值为3 第二次 a的值为4
cpp
fun(s, n1, n2)
int* s, n1, n2;
{
int i, j, t;
i = n1; j = n2;
while (i<j)
{
t = *(s + i);
*(s + i) = *(s + j);
*(s + j) = t;
}
}
int main() {
int a[10] = { 1,2,3,4,5,6,7,8,9,0 }, i, * p = a;
fun(p, 0, 3);
fun(p, 4, 9);
fun(p, 0, 9);
for (i = 0; i < 10; i++)
printf("%d", *(a + i));
printf("\n");
}该程序主要实现数组中元素的顺序调换 第一次函数调用就是将元素1 4 2 3调换 变成4321
第二次函数调用 将5 0 6 9 ....调换 变成098765 第三次函数调用 将整一个数组调换 最后变成5678801234
cpp
int main() {
int a[] = { 1,2,3,4 }, i;
int x = 0;
for (i = 0; i < 4; i++) {
sub(a, x);
printf("%d", x);
printf("\n");
}
}
sub(int* s, int y)
{
static int t = 3;
y = s[t]; t--;
}输出是
0 0 0 0因为没有正确地传递x的地址，或者在sub函数中没有正确修改x。请确保以下几点：
确保传递地址 ：在
main函数中调用sub时，确保使用&x传递x的地址。确保正确使用指针 ：在
sub函数中，要确保通过解引用指针来修改y的值。
cpp
#include <stdlib.h>
#include <stddef.h>
void fun(float* p1, float* p2, float* s)
{
s = (float*)malloc(1, sizeof(float));
*s = *p1 + *(p2++);
}
int main() {
float a[2] = { 1.1,2.2 }, b[2] = { 10.0,20.0 }, * s = a;
fun(a, b, s);
printf("%f", *s);
}在
fun函数中对s的处理不当。将s的值修改为指向新分配的内存，但在main中仍然使用未更新的s。 输出还是 1.100000
15.假设a和b为int型变量，则执行以下语句后，b的值为 D__。
a=1；b=10； do {b-=a；a++； }while(b--＜0)； A．9B．-2C．-1D．8
第一次循环 b=8 不小于0 结束循环 所以b为8
16.当运行以下程序时,从键盘输入:AhaMA Aha
cpp
int main() {
char s[80]; // 定义字符数组 s
char c = 'a'; // 小写字母
int i = 0; // 索引初始化
// 输入字符串
scanf("%s", s);
// 遍历字符串
while (s[i] != '\0') {
if (s[i] == c) {
s[i] = s[i] - 32; // 将小写字母转换为大写
}
else if (s[i] == c - 32) {
s[i] = s[i] + 32; // 将大写字母转换为小写
}
i++; // 增加索引
}
// 输出结果
puts(s);
return 0;
}1.要注意一个点 输入一个AhaMA Aha 中间有个空格,所以他只读到第一个空格前的内容
2.while循环的目的就是将 a和A 的大小写互换 最终输出 ahAMa
17 以下程序输出什么?
cpp
int main() {
struct p
{
char name[9];
int age;
};
struct p class[10] = { "John",17,"Paul",19,"Marry",18,"Adam",16 };
printf("%c", class[2].name[0]);
}输出字母M 结构体的输出 . 成员变量
18.假定下列程序的可执行文件名为prg . exe,则在该程序所在的子目录下输入命令行: prg hello good<回车〉后,程序的输出结果是()
main(int argc, char *argv[ ])
{int i; if(argc〈=0) return; for(i=1; i〈argc; i++) printf("%c", *argv[i]); }
argc计数参数的数量，包括程序名称。输入命令prg hello good后，argc的值是 3（程序名、hello和good）。由于i从 1 开始循环到argc - 1，*argv[i]将取每个参数的第一个字符。因此，输出为h（来自hello）和g（来自good），最终结果是hg。
19.下列程序输出结果是 15
cpp
#define MIN(x,y) (x)<(y)?(x):(y)
int main() {
int i, j, k;
i = 10; j = 15;
k = 10 * MIN(i, j);
printf("%d", k);
}解析:错误解法 先算10<15?10:15 返回 10 k=10*10=100
宏定义 是整体替换的 正确的解法: 10*10<15?10:15 100不小于15 返回15
20.以下语句定义正确的是 D
cpp
int main() {
int a[1][4] = { 1,2,3,4,5 };
float x[2][] = { {1},{2},{3} };
long b[2][3] = { {1},{1,2},{1,2,3} };
double y[][3] = { 0 };
}语句 1 一行四列的二维数组 但是在赋值时,是五个元素,越界
语句 2 [][] 列数不能为空
语句 3 定义一个 二行三列的数组 赋值时为三行 报错
语句 4 正确
这个值是基于结构体
struct test的组成成分来计算的。具体来说，结构体struct test包含以下几个部分：
- 一个整数类型成员
int m1，通常占用2个字节（这取决于编译器和平台，但大多数现代编译器中，int类型占用4个字节，但考虑到题目可能是在特定的环境下提问，我们按照2个字节来计算）。- 一个字符类型成员
char m2，占用1个字节。- 一个浮点数类型成员
float m3，占用4个字节。- 一个共用体
union uu，它包含两个选项：一个字符数组char u1:ml-citation{ref="1" data="citationList"}占用5个字节，和一个整数数组int u2:ml-citation{ref="2" data="citationList"}占用4个字节。由于共用体中的所有成员共享同一块内存区域，因此共用体的大小取决于其最大的成员，即5个字节。根据上述分析，结构体
struct test的总大小为：2（m1）+1（m2）+4（m3）+5（共用体）=122（m1）+1（m2）+4（m3）+5（共用体）=12个字节。因此，sizeof(struct test)的值是12
22.下列程序段不是死循环的是________。
A. int s=36; while(s); --s;
B. int i=100; while(1) {i=i%100+1; if(i>100) break;}
C. int k=0; do{++k;}while(k>=0);
D. for( ; ; );
选C 解析: C选项 不会死循环 int有个范围 加到一定的值他会变负数 最终跳出循环
有歧义的是A 我们可以观察到 while后面有个 ; 所以 --s是不会被执行的 所以构成死循环
23.A正确
Strcpy (p = a + 1， & st [4]);从st［4］到p，p＝＂areyou＂
B，a是一个字符数组的名字。这是一个地址。不能做＋＋a
C．因为＊st＝"how are you"；有11个字符，包括＼0，有12个字符。所以a[11]中最多只能存放11个元素 没有复制＼0。最终没识别到\0 停止
D。［］不声明数组的大版本。
24.以下程序输出的结果是:
cpp
int main() {
char* p1, * p2, str[50] = "xyz";
p1 = "abcd";
p2 = "ABCD";
strcpy(str + 2, strcat(p1 + 2, p2 + 1));
printf("%s", str);
}代码存在未定义问题,在编写时最好用数组存放; 我们从做题角度去看的话,strcat函数是字符串拼接 将第二个参数拼接到第一个参数上 p2+1==>取BCD p1+2 ==>取cd 所以将BCD拼接到cd后得到 cdBCD 然后 str+2 表示 从z开始复制 最后 输出 xycdBCD
25.以下输出结果是: 6
cpp
struct abc
{
int a, b, c;
};
int main() {
struct abc s[2] = { {1,2,3},{4,5,6,} }; int t;
t = s[0].a + s[1].b;
printf("%d", t);
}结构体 s[0] 初始化为{1,2,3} s[1] 初始化为{4,5,6} 结构体中的 a b c被赋值为 1 2 3 或者 456
当s[0].a 就是 输出 1 s[1].b 输出 5 最后 5+1 输出 6
cpp
void fun(int* a, int* b)
{
int* k;
k = a; a = b; b = k;
}
int main() {
int a = 3, b = 6, * x = &a, * y = &b;
fun(x, y);
printf("%d %d", a, b);
}在C语言中，调用函数时是将实参复制一份给形参，所以无论怎么改变形参的值，都不会影响到实参，即传值调用。即使形参是指针变量，也没有改变C语言传值调用这个事实，实参指针也还是复制了一份给形参指针，无论怎么改变形参指针的内容(注意：不是形参指针所指向的内容)，也不会影响实参指针的内容。但它们两个现在的值一样，即指向的是同一个内存地址，所以改变形参指针所指向的内容，也就改变了实参指针所指向的内容，C语言就是这样实现传址调用的。本题中fun()函数的形参就是两个指针，但函数中没有任何语句改变这两个指针所指向的内容，只是交换了两个参数的内容，所以该函数不会对传递给它的实参以及实参所指向的内容造成任何影响，故a，b初始化时为3，6，输出结果亦为3和6
27.下面程序的输出结果为( )。
cpp
struct st {int x;int *y;}*p; int dt[4]={10,20,30,40);
struct st aa[4]={50,&dt[0],60,&dt[1],70,&dt[2],80,&dt[3]};
int main( ) {
p=aa;
printf("%d\n",++p->x);
printf("%d|n",(++p)->x);
printf("%d\n",++(*p->y));
}A. 10 20 20
B. 50 60 21
C. 51 60 21
D. 60 70 31
解析:第1个输出语句中由于->的优先级高于++,因此先取结构体的分量x,再对x的值加1,再输出。p的初值为结构体数组aa的首地址即a[0]的地址,a[0]的x分量值为50,加1后输出51。第2个输出语句中++p被括号括起来,括号的优先级与->相同,自左至右结合,因此先对p加1,再取p所指向的元素的x分量的值。p加1后p指向数组元素a[1],a[1]的x分量的值为60,输出60。第3个输出语句中括号的优先级高于++,因此先求括号中表达式的值,又由于->的优先级高于*,所以先取p所指向的数组元素的y分量的值,p所指向的元素为a[1],y分量的值为&dt[1]。&dt[1]是一个存储单元的地址,是数组dt第2个元素的地址值,再取该存储单元中的值为20,最后对20加1,输出21。
28.以下程序输出的结果为:
cpp
main()
{int a[6],i;
for(i=1;i<6;i++)
{ a[i]=9*(i-2+4*(i>3))%5;
printf("%2d",a[i]);
}
}A)-4 0 4 0 4 B)-4 0 4 0 3 C)-4 0 4 4 3 D)-4 0 4 4 0
解析 我们直接看 i=5的时候, 9*(5-2+4*1)%5 = 63%5=3 排除AD 然后计算i=4 9*(4-2+4)%5=54%5=4 *的优先级比%更高;
29.以下程序输出的结果为:
cpp
union myun {
struct {
int x, y, z;
} u;
int k;
} a;
int main() {
a.u.x = 4;
a.u.y = 5;
a.u.z = 6;
a.k = 0;
printf("%d", a.u.x);
}在这个例子中，你先为结构体
u的成员x,y,z赋值，然后将k赋值为 0。由于联合体的特性，赋值k会覆盖之前的结构体成员。因此，printf("%d", a.u.x);输出的将是一个未定义的值，因为a.u.x的值已经被k的赋值覆盖。具体的输出会取决于内存的状态，但通常情况下这会导致程序不按预期工作。如果你想确保能够打印出
a.u.x的值，你应该避免给k赋值，或者使用结构体成员，而不是联合体。
30.以下程序输出什么
cpp
#include <stdio.h>
void main()
{
union
{
unsigned char c;
unsigned int i[4];
}z;
z.i[0]=0x39;
z.i[1]=0x36;
printf("%c\n",z.c);
}
联合体的内存共享：在联合体中，所有成员共享相同的内存空间。这意味着对一个成员的赋值会影响到其他成员。
赋值过程 ：你将
i[0]设置为0x39，这实际上在内存中写入了这个值。0x39的二进制表示是00111001，对应的 ASCII 字符是'9'。打印字符 ：当你使用
printf("%c\n", z.c);打印z.c的值时，程序读取的是i[0]的低字节（0x39），所以打印出'9'。
31.正确的答案是（）
若有代数式3ae/bc,则不正确的c语言表达式是（）
A.a/b/c*e*3 B.3*a*e/b/c C.3*a*e/b*c D.a*e/c/b*3
在C语言中，表达式的计算顺序是根据运算符的优先级和结合性规则来确定的。需要确保在C语言表达式中正确地表示这个数学表达式。
选项A:
a/b/c*e*3
- 这个表达式首先计算
a/b，然后结果除以c，最后乘以e和3。这符合原数学表达式的结构。选项B:
3*a*e/b/c
- 这个表达式首先计算
3*a*e，然后结果除以b，最后除以c。这也符合原数学表达式的结构。选项C:
3*a*e/b*c
- 这个表达式首先计算
3*a*e，然后结果除以b，最后乘以c。这不符合原数学表达式的结构，因为在数学表达式中c是分母的一部分，而在C语言表达式中它被错误地放在了分子的位置。选项D:
a*e/c/b*3
- 这个表达式首先计算
a*e，然后结果除以c，再除以b，最后乘以3。这也符合原数学表达式的结构。
32.已有如下定义和输入语句,若要求a1,a2,c1,c2的值分别为10,20,A和B,当从第一列开始输入数据时,正确的输入方式是( D )。(代表空格,↙代表Enter)
int a1,a2; char c1,c2;
scanf("%d%d",&a1,&a2);
scanf("%c%c",&c1,&c2);
A. 1020AB↙
B. 1020↙
C. 1020AB↙
D. 10 20AB↙
D 选项 10后有一个空格 结束 将10赋值给a1 然后输出20A 遇到字符 结束 将20赋值给a2 最后将AB 赋值c1 c2
33.下面四个选项中，均是不合法的整型常量的选项是( )。
A．--0f1 -oxffff 0011
B．-0xcdf 017 12,456
C．-018 999 5e2
D．-0x48e -068 03f
补充一条重要的知识点
整形常量:
1.十进制一般都是 12 15 21等等形式
2.八进制各位的数值只能是0-7 并且以0开头, 比如:011 015 031 044 等等
3.十六进制各位的数值只能是0-9 或者 A-F 并且以 0x开头 比如 0x11 0xfff 等等
4.e 后跟着的指数必须是整数 不能是浮点数 例如:-8e 5e3 等等
然后我们看回本题目 D选项都是不合法的整型常量 -0x48e -068和03f(不是合法的八进制)'''
34.以下程序输出的结果为 D
cpp
main()
{ int x,i;
for(i=1;i<=100;i++)
{ x=i;
if(++x%2==0)
if(++x%3==0)
if(++x%7==0)
printf("%d ",x);
} }A)39 81 B)42 84 C)26 68 D)28 70
- 循环 ：
for(i=1;i<=100;i++)，遍历i从1到100。- 自增和条件判断 ：
- 第一次自增
++x：x变为i + 1，检查是否能被2整除。- 如果满足，再进行第二次自增
++x：x变为i + 2，检查是否能被3整除。- 如果仍然满足，最后进行第三次自增
++x：x变为i + 3，检查是否能被7整除。- 如果我们只查看
i + 3满足42的倍数，实际上：
- 28：
i + 3 = 28，即i = 25->x = 28- 70：
i + 3 = 70，即i = 67->x = 70
35.程序输出的结果是 k=8 b=-2
cpp
#include <stdio.h>
int main() {
int i, b, k = 0;
for (i = 1; i <= 5; i++) {
b = i % 2; // b = 0 (偶数) 或 1 (奇数)
while (b-- >= 0) { // 当 b 为 0 或 1 时，循环体执行
k++; // 计数器加 1
}
}
printf("%d, %d", k, b); // 打印 k 和 b 的值
return 0;
}解析:看到关键的b = i%2 判断b是偶数还是奇数; 如果是奇数while循环两次 偶数循环一次 则循环一共执行8次 最终k的值为8 b=-1
36.输入3.6 2.4回车,则结果为(1.6)
cpp
main()
{
float x,y,z;
scanf("%f%f",&x,&y);
z=x/y;
while(1)
{
if (fabs(z)>1.0)
{
x=y; y=z; z=x/y;
}
else break;
}
printf("%f\n",y);
}解析:fabs() 是绝对值函数,第一次循环 z=3.6/2.4 = 1.5
if语句满足则进入判断 x=2.4 y=1.5 z=2.4/1.5 = 1.6 进入第二次循环 x=1.5 y=1.6 z=1.5/1.6=0.93 不满足循环 最后输出 y=1.6
37.以下程序输出的结果是()
cpp
int main() {
int a, b;
for (a = 1, b = 1; a <= 100; a++) {
if (b >= 20) break; // 如果 b >= 20，退出循环
if (b % 3 == 1) { // 如果 b 除以 3 的余数为 1
b += 3; // 将 b 增加 3
continue; // 跳过当前迭代，继续下一次循环
}
b -= 5; // 否则，b 减去 5
}
printf("%d\n", a); // 打印 a 的值
return 0;
}解析:首先要明确for循环的执行顺序
for(语句1;语句2;语句3)
循环的语法形式如下：
初始化只执行一次
循环次数主要看表达式2 一直为真就一直执行,表达式2至关重要
a=1 b=4
a=2 b=7
a=3 b=10
a=4 b=13
a=5 b=16
a=6 b=19
a=7 b=22
因为是a++ 后置加一 所以最后输出 8
若二维数组a有m列,则计算任一元素a[i][j]在数组中位置的公式为:[ i*m+j-1 ]。(假设a[0][0]位于数组的第一个位置上。)
若二维数组a有m列 则a[i][j]前的元素个数为 i*m+j