更新C语言题目

1.以下程序输出结果是()

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.以下程序输出结果是()

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.以下程序输出结果是()

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.以下程序输出结果是()

#define P 3
#define S(a) P*a*a
int main() {
	int ar;
	ar = S(3 + 5);
	printf("%d", ar);
}

5.以下程序输出结果是()

#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.以下程序输出结果是()

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没有变化

#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 。

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

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

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选项

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。

int main() {
    int x = 023;
    printf("%d", --x);
}

023 是八进制转成十进制对应是 2*8^1+3*8^0=19 --x 则输出18

10.

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

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

11.

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

12.

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

13.

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 的值。

14.

#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

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 以下程序输出什么?

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

#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

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 正确

21.

这个值是基于结构体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.以下程序输出的结果是:

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

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

26.

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.下面程序的输出结果为( )。

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.以下程序输出的结果为:

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.以下程序输出的结果为:

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.以下程序输出什么

#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

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

#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)

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.以下程序输出的结果是()

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