2019-C言语二级考题库

• 四季题材trong>单项可以选择题

1．（A 组成C言语顺序的根本单元。

A 函数B进程 C子程序 D子例程

2．C言语顺序从C开端中执行。

A顺序中第一条可执行语句B顺序中第一个函数

C顺序中的main小说题材函数D包括文件中的第一个函数

3以下说法中正确的C

AC言语顺序总是从第一个定义的函数开端中执行

BC言语顺序中，要调用的函数必需在main函数中定义

CC言语顺序总是从main函数开端中执行

DC言语顺序中的main函数必需放在顺序的开端局部

4.下述有关C言语的说法错误瀑布题材的的B

A C顺序的任务进程是责编、编译、衔接、运转

BC言语不划分巨细写

CC顺序的三种基本结构是先后顺序、可以选择、循坏

DC顺序从main函数开端中执行

5.下述准确的标识符是C

A .-a1B.a[影视题材i]C.a2_iD.intt

5~8题为相反不同类型题

考点：标识符的为命名基本规则

选项A 中的–选项B中[与]非常不满足（1选项D中的int为关键字，非常不满足（3

6．下列C言语用户标识符中合法的B

A3axBxCcaseD-e2Eunion

选项A 中的标识符以数字扫尾非常不满足（2选项CE均为为关键字，非常不满足（3选项D中的–非常不满足（1

7．下述四组选项中，准确的C言语标识符是C

A %xBa+bCa123D123

选项A 中的%选项B中+非常不满足（1选项D中的标识符以数字扫尾非常不满足（2

8下述四组字符串中都可以用作C言语顺序中的标识符的A

Aprint_3ddb8aBcBIamone_halfstart$it3pai

Cstr_1CpppowwhileDPxqMy->bookline#His.ag

选项B中的$选项D中>#.–非常不满足（1选项C中的while为关键字，非常不满足（3

9.C言语中的复杂数据不同类型包罗（D

A整型、实型、逻辑型 B整型、实型、逻辑型、字符型

C整型、字符型、逻辑型 D整型、实型、字符型

10.C言语顺序中，直接表达式影视题材5%2后果是C

A2.5B2C1D3

详见教材P52~53.

%为求余运算符，该运算符只能对整型数据停止运算。且象征符号与被模数相同。5%2=15%-2=1-5%2=-1-5%-2=-1

/为求商运算符，该运算符可以对整型、字符、浮点等类型的数据停止运算，5/2=2

11．如果inta=3,b=4则基本条影视题材件直接表达式”a<b?a:b”值是__A __

A 3B4C0D1

详见教材P97.

直接表达式1直接表达式2直接表达式3

先盘算直接表达式1

若表小说题材达式1建立，则可以选择盘算直接表达式2并将表达式2值作为整体大表达式的值；

若表达式1难不成立，则可以选择盘算直接表达式3并将表达式3值作为整体大表达式的值

此题中的a<b非常于表达式1a非常于表达式2b非常于表达式3.

a为3b为4a<b直接表达式1建立，因而盘算直接表达式2并将表达式2值即a中的值，并作为整体直接表达式的值，因而整体直接表达式的值为3

12．若intx=2,y=3,z=4则表达式x<z?y:z后果是B

A4B3C2D0E1

13．C言语中，之间的关系直接表达式和逻辑直接表达式的值是B

A0B0或1C1DT或’F

14.上面D直接表达式的值为4.

A11/3B11.0/3

Cfloat11/3Dint11.0/3+0.5

14~16题为同一类型

详见教材P54~56.

1相反数据不同类型的元素停止数学运算（+–*/得到后果还坚持原数据类型。

2差别数据不同类型的元素停止数学运算，先要一致数据不同类型，一致的规范是低精度不同类型转换为高精度的数据不同类型。

选项A 11与3为两个整数，11/3后果的数据不同类型也应为整数，因而将3.666666小数局部所有舍掉，仅保留整数，因而11/3=3.

选项B11.0为实数，3为整数，因而先要一致数据不同类型，将整型数据3转换为3.0转换后数据不同类型一致为实型数据，选项B变成11.0/3.0,后果的数据不同类型也应为实型数据，因而选项B11.0/3=3.666666

选项C先将整数11强迫不同类型转换，转换为实型11.0因而选项C变成11.0/3厥后盘算进程、后果与选项B同

选项D先盘算11.0/3其计算过程、后果与选项B同，得到3.666666再计算3.666666+0.5=4.166666最初将4.166666强迫不同类型转换为整型，行将其小数局部所有舍掉，后果为4

15.设整型变量 a=2则中执行下述语句后，浮点型变量b值不为0.5B

A .b=1.0/aB.b=float1/a

C.b=1/floataD.b=1/a*1.0

16.若“intn;floatf=13.8;,则执行“n=intf%3后，n值是A

A .1B.4C.4.333333D.4.6

intf表现将f中的值强迫不同类型转换为整型，行将13.8小数部分舍掉，转换为13接着盘算13%3后果为1再将后果赋给变量n因而n值为1

17.以下对一维数组a准确阐明是D

Cintk＝5a[k]Dchara[3]={a,b,c};

详见教材P143~144一维数组的界说、初始化

不同类型符数组名[常量表达式]

不同类型符是指数组中数组元素的不同类型；数组名要契合标识符命名规则；常量表达式是指数组的长度（数组中包含元素的个数）其值只能是整数，不行以是变量，并且从1开端计数。

选项A 常量直接表达式只能放在中括号[]中

选项B只要在对数组初始化（即赋值）时分才也可以省略数组的长度，B中并未对a停止初始化。

选项C常量直接表达式不能够为变量。

18.以下能对一维数组a停止初始化的语句是:C

A.inta[5]=0,1,2,3,4,B.inta5={}

C.inta[3]={0,1,2}D.inta{5}={10*1}

详见教材P145一维数组的界说、初始化

选项B,D常量直接表达式只能放在中括号[]中

选项A 数组可以看做是及一个相反数据不同类型元素的有序荟萃，因而以集合的方式对其初始化，运用{}对其初始化，选项A 用了.

19.C言语中对一维整型数组的准确界说为 D

Ainta10;Bintn=10,a[n];

Cintn;a[n];D#defi四季题材nN10

inta[N];

20已知：inta[10];则对a数组元素的准确援用是D

Aa[10]Ba[3.5]Ca5Da[0]

详见教材P144数组元素的援用

数组名[下标]

援用数组元素时，[]中的下标为逻辑餐厅地址下标，只能为整数，也可以为变量，且从0开端计数

inta[10]表现界说了一个包含10个整型数据的数组a数组元素的逻辑餐厅地址下标范围为0~9即a[0]表现组中第1个元素;a[1]表现组中第2个元素;a[2]表现组中第3个元素;……;a[9]表现组中第10个元素.

选项A 超越了数组a逻辑餐厅地址下标范围；

选项B逻辑餐厅地址下标只能为整数

选项C逻辑餐厅地址下标只能放在[]中

21.如有以下数组说明，则i=10;a[a[i]]元素数值是C

inta[12]={1,4,7,10,2,5,8,11,3,6,9,12};

A .10B.9C.6D.5

先算a[a[i]]内层的a[i]因为i=10,因而a[i]即a[10].

a[10]对应上面数组中的元素为9.因而a[a[i]]即为a[9]

a[9]对应上面数组中的元素为6.因而a[9]即为6

22.如有阐明：inta[][3]={{1,2,3},{4,5},{6,7}};则数组a第一维的巨细为:B

A.2B.3C.4D.无确定值

二维数组的一维大小，即指二维数组的行数，本题中，按行对二维数组赋值，因而内层有几个大括号，数组就有几行

23.对二维数组的准确界说是C

A.inta[][]={1,2,3,4,5,6};B.inta[2][]={1,2,3,4,5,6};

C.inta[][3]={1,2,3,4,5,6};D.inta[2,3]={1,2,3,4,5,6};

选项A ,B都省略了列数

选项D不符合二维数组定义的普通方式，行、列常量直接表达式应该放在差别的[]中

详见教材P149~152二维数组的界说、初始化

不同类型符数组名[常量表达式][常量表达式]

二维数组可以看做是矩阵

不同类型符是指数组中数组元素的不同类型；数组名要契合标识符命名规则；第一个常量表达式是指数组的行数；第二个常量表达式是指数组的列数；常量表达式的值只能是整数，不行以是变量，并且从1开端计数。

一维数组初始化时也可以省略数组长度

二维数组初始化时也可以省略行数，但不能够省略列数

24．已知inta[3][4];则对数组元素援用准确的__C___

Aa[2][4]Ba[1,3]Ca[2][0]Da21

本题图示详见P149图6.7

因而a行逻辑餐厅地址规模0~2a列逻辑餐厅地址规模0~3

选项A 列逻辑餐厅地址下标超过范围

选项B,D援用方式不正确。

详见教材P150数组元素的援用

数组名[下标][下标]

援用数组元素时，[]中的下标为逻辑餐厅地址下标，只能为整数，也可以为变量，且从0开端计数

第一个[下标]表现行逻辑餐厅地址下标，第二个[下标]表现列逻辑餐厅地址下标。

25.C言语中函数前往值的不同类型是由A 决议的.

A 函数界说时指定的不同类型Breturn语句中的直接表达式类型

C挪用该函数时的实参的数据不同类型 D形参的数据不同类型

26.C言语中，函数的数据不同类型是指(A

A 函数前往值的数据不同类型B.函数形参的数据不同类型

C挪用该函数时的实参的数据不同类型 D.恣意指定的数据不同类型

27.函数挪用时，以下说法准确的B

A .函数挪用后必需带回返回值

B.实践参数和方式参数也可以同名

C.函数间的数据通报不行以运用全局变量

D.主调函数和被调函数总是统一个文件里

28.C言语中，表现静态和动态存储种别的要害字是:C

A autoBregistCstaticDextern

29．未指定存储种别的变量，其隐含的存储种别为（A

AautoBstaticCexternDregister

30.如有以下阐明语句：

structstudent

{intnum;

charname[];

floatscore;

}stu;

则下面的叙说不正确的:D

A .struct构造体类短片题材型的要害字

B.structstudent用户界说的构造体类型

C.num,score都是构造体成员名

D.stu用户界说的构造体类型名

31.如有以下阐明语句：

structdate

{intyear;

intmonth;

intday;

}brithday;

则下面的叙说不正确的__C___.

A struct官方声明构造体类型时用的要害字

Bstructdate用户界说的构造体类型名

Cbrithdai用户界说的构造体类型名

Dyear,dai都是构造体成员名

32.以下对结构变量stul中成员ag合法援用是B

structstudent

{intag

intnum

}stu1,*p

p=&stu1

A stu1.agBstudent.agCp->ageD*p.age

33.设有如下所示界说：

strucksk

{inta;

floatb;

}data;

int*p;

若要使P指向data中的a域，准确的赋值语句是C

A p=&a;Bp=data.a;Cp=&data.a;D*p=data.a;

34.设有以下阐明语句：

typedefstructstu

{inta;

floatb;

}stutype;

则上面叙说中错误的D

Astruct构造不同类型的要害字

Bstructstu用户界说的构造不同类型

Ca和b都是构造成员名

Dstutyp用户界说的构造体变量名

35． 语句int*p;阐明了C

A p指向一维数组的指针

Bp指向函数的指针,该函数前往一int型数据

Cp指向int型数据的指针 //指针的界说课本P223

Dp函数名,该函数前往一指向int型数据的指针

36．下述不正确的界说是A

C．inti,短片题材*p=&i;D.inti,*p;

选项A 先界说一个整型指针变量p接着将变量i餐厅地址赋给p但是此时还还未定义变量i因而编译器难以取得变量i餐厅地址。A与C比照，选项C先定义变量i则在内存中为i平均分配空间，因而i内存空间的餐厅地址就可以确定了接着再定义p此时也可以为p赋i餐厅地址，C准确

37.如有阐明：intn=2,*p=&n,*q=p,则以下非法的赋值语句是:D

A p=qB*p=*qCn=*qDp=n

p,q同为整型指针变量，两者外面仅能寄存作文题材整型变量的餐厅地址。

选项A q中为地址，因而可将此地址赋给p

选项B*p表现p所指向对象n其他内容，即一个整数；*q表现q所指向对象的其他内容，因为在界说q时为其初始化，将p中n餐厅地址给q因而p中存放n餐厅地址，*q表现q所指向对象n其他内容.因而*p=*q非常于n=n;

选项Cn=*q等价于n=n;

选项Dp中只能寄存餐厅地址，不能够将n中的整数值赋给p

38．有语句：inta[10];则B对指针变量p准确界说和初始化。

A intp=*a;Bint*p=a;Cintp=&a;Dint*p=&a;

选项A a数组名，不是指针变量名，因而不行用*标注数组名a

选项Ca数组名，数组名就是餐厅地址，无需再用地址符号。并且在界说指针变量p时，应在变量名前加*标注p指针变量

选项Da数组名，数组名就是餐厅地址，无需再用地址符号。

39.如有阐明语句“inta[5],*p=a;,则对数组元素的准确援用是C

A .a[p]B.p[a]C.*p+2D.p+2

先界说一个整型数组aa长度为5接着界说一个指针变量p并同时对p停止初始化，将数组a餐厅地址赋给p因而此时p中存放的数组a首地址，即数组中第一个元素a[0]餐厅地址。

关于数组元素下标的援用详见p144,普通方式数组名[下标]其中包括下标为逻辑餐厅地址下标，从0开端计数，方括号中的下标可以是变量，也可以是直接表达式，但后果肯定要是整数。

选项A p中存放的餐厅地址，不是整数，不能够做数组元素的下标

选项Ba数组名，数组名就是餐厅地址，不是整数，不能够做数组元素的下标

选项C重点！详见p231~234p+2表现指向统一数组中的下两个元素的餐厅地址，以后p指向a[0]则p+2表现a[2]餐厅地址，因而*p+2表现a[2]其他内容

40.有如下程序

inta[10]={1,2,3,4,5,6,7,8,9,10},*P=a;

则数值为9直接表达式是B

A *P+9B*P+8C*P+=9DP+8

重点！详见p231~234

先界说一个整型数组aa长度为5接着界说一个指针变量P并同时对P停止初始化，将数组a餐厅地址赋给P因而此时P中存放的数组a首地址，即数组中第一个元素a[0]餐厅地址。

数组中9对应的a[8],选项BP+8表现数组中后8个元素的餐厅地址，即a[8]餐厅地址。*P+8则表现该地址内所存放的其他内容，即a[8]值。

选项A *P表现P所指向对象的其他内容，此时P指向a[0],*P即a[0]值1.*P+9=1+9=10

选项C*P表现P所指向对象的其他内容，此时P指向a[0],*P即a[0]值。因而*P+=9即*P=*P+9,等价于a[0]=a[0]+9.

选项DP+8表现数组中后8个元素的餐厅地址，即a[8]餐厅地址，而非a[8]中的值。

41.C言语中，以 D作为字符串结束标志

A nBC0D0

42.下述数据中属于“字符串常量”A

A .aB.{A BC}C.abc0D.a

及一个字符组成字符串

C言语中，用单引号标识字符；用双引号标识字符串

选项BC辨别用{}和标识字符串

选项D标识字符。

43.已知charx[]=”hello”,y[]={\’h\’,\’e\’,\’a\’,\’b\’,\’e\’};,则有关两个数组长度准确描绘是B.

A 相反 Bx大于yCx小于yD以上谜底都不对

C言语中，字符串前面需求一个完毕标识位\’0\’一般零碎会自动添加。

对一维数组初始化时可接纳字符串的方式（比如本题数组x也可接纳字符集合的方式（比如本题数组y以字符串方式初始化时，数组x不尽要存储字符串中的字符，还要存储字符串后的完毕标识位，因而数组x长度为6以字符集合方式初始化时，数组y仅存储荟萃中的元素，因而数组y长度为5

• 读程序

根本输出输入及流程控制

#inclu学生题材d<stdio.h>

main

{inta=1,b=3,c=5;

ifc==a+b

printf”yesn”短片题材;

else

printf”non”;

运转后果为：no

详见教材p89可以选择构造

详见教材p91之间的关系象征符号

详见附录Dp378象征符号的优先级

==表现判别象征符号双方的值是否相等；=表现将符号右边的值赋给左边的变量

本题考点是可以选择构造3种基本形式的第二种

可以选择构造三种普通方式中的语句皆为复合语句，复合语句要用视频题材{}括起来，只要当复合语句中只包罗一条语句时可以省略{}此题即如此，因而两个printf操作方式也没加{}

若c==a+b建立，则执行printf”yesn”;

否者（即c==a+b难不成立）中执行printf”non”;

+优先级高于==因而先算a+b,值为4直接表达式5==4难不成立，因而中执行printf”non”;即输入字符串no

2.

#includ<stdio.h>

main

{inta=12,b=-34,c=56,min=0;

min=a;

ifmin>b

min=b;

ifmin>c

min=c;

printf”min=%d”,min;

运转后果为min=-34

详见教材p89可以选择构造

本题考点是可以选择构造3种基本形式的第一种

一共包括了两个选择结构（两个if语句）

界说变量，并赋值此时a=12,b=-34,c=56,min=0

将a中值拷贝，赋给min掩盖了min中的0此时min中的值被更新为12

若min>b建立，则执行min=b;

若min>c建立，则执行min=c;

输入min中的值

12大于-34,第一个if语句的直接表达式成立，因而中执行min=b;中执行后min中的值被更新为-34.

-34小于56,第二个if语句的直接表达式不成立，因而不执行min=c;

最初输入min中的值，为-34.

#includ<stdio.h>

main

{intx=2,y=-1,z=5;

ifx<y

ify<0

z=0;

else

z=z+1学生题材;

printf%dn,z;

运转后果为5

遇到可以选择构造，先要明白基本条件直接表达式建立时中执行哪些操作方式。本题中，第一个if语句，厥后的复合语句也没大括号{}阐明复合语句中只包括一条语句，进而省略了{}内层的if…else…可以选择构造的第二种基本形式，构造上视为一条语句。因而内层的if…else…作为第一个if语句的复合语句。

若表达式x<y建立，则继续判断

若y<0则执行z=0;

否者（即y>=0,中执行z=z+1;

输入z

2>-1直接表达式x<y难不成立，因而不执行内层的ifels.进而z中的值也没被改变。

输入z中的值为5

4.

#includ<stdio.h>

main

{floata,b,c,t;

a=3;

b=7;

c=1;

ifa>b

{t=a;a=b;b=t;}

ifa>c

{t=a;a=c;c=t;}

ifb>c

{t=b;b=c;c=t;}

printf”%四季题材5.2f,%5.2f,%5.2f”,a,b,c;

运转后果为：1.00,2.00,7.00

详见教材p72数据的输入方式

本题包含了3个if语句，每一if语句后的{}都不可省略，由于每一{}中都包含了多条语句

若表达式a>b建立，则执行{t=a;a=b;b=t;}

若表达式a>c建立，则执行{t=a;a=c;c=t;}

若表达式b>c建立，则执行{t=b;b=c;c=t;}

输入a,b,c中的值，其要求输入的每一数据宽度为5个空格，小数部分保留2位，数据右对齐

3小于7,因而直接表达式a>b难不成立，因而不执行{t=a;a=b;b=t;}

3大于1因而直接表达式a>c建立，则执行{t=a;a=b;b=t;}第一句，将a中的3拷贝，粘贴到t中；第二句，将c中的1拷贝，粘贴到a中，掩盖掉先前的3第三句。将t中的3拷贝到c中，掩盖掉c中先前的1.中执行完复合语句后实现了a,c元素的值的交换，a为1c为3t为3

7大于c中的3因而b>c建立，中执行则执行{t=b;b=c;c=t;}进程同上，中执行后b为3c为7t为7

此时输入a,b,c中的值为1.00,2.00,7.00

5．

#includ<stdio.h>

main

{floatc=3.0,d=4.0;

ifc>dc=5.0;

els

ifc==dc=6.0;

elsc=7.0;

printf%.1fn,c;

运转后果为7.0

此题为if…else…语句的嵌套，第二if…else…作为第一个if…else…语句else局部的复合语句。

若表达式c>d建立，则执行c=5.0;

否者（直接表达式c>d难不成立）

若表达式c==d建立，则执行c=6.0;

否者，中执行c=7.0;

输入c中的值

3.0小于4.0因而直接表达式c>d难不成立中执行第二个ifels

3.0不等于4.0因而直接表达式c==d难不成立，中执行c=7.0将7.0赋给c,掩盖掉c中的3.0此时c中的值为7.0

输入此时的c中的值

#includ<stdio.h>

main

{intm;

scanf”%d”,&m;

ifm>=0

{ifm%2==0printf”%disapositevenn”,m;

elsprintf”%disapositoddn”,m;}

els

{ifm%2==0printf”%disanegevenn”,m;

elsprintf”%disanegoddn”,m;}

若键入－9则运转后果为:-9isanegodd

7.

#includ<stdio.h>

main

{intnum=0

whilnum<=2

{num++

printf”%dn”,num}

运转后果为：

详见教材p115循坏构造

当循环条件num<=2建立的时分，中执行循瀑布题材坏体{num++printf”%dn”,num}中的语句。

循坏初值num为0;

循坏基本条件num<=2建立

第1次循环：中执行num++;行将num中的值加1中执行后num为1

中执行printf”%dn”,num屏幕上输出num中的值，即输出1后换行

此时num中的值为1循坏基本条件num<=2建立

第2此循环：中执行num++;行将num中的值加1中执行后num为2

中执行printf”%dn”,num屏幕上输出num中的值，即输出2后换行

此时num中的值为2循坏基本条件num<=2建立

第3此循环：中执行num++;行将num中的值加1中执行后num为3

中执行printf”%dn”,num屏幕上输出num中的值，即输出3后换行

此时num中的值为3循坏基本条件num<=2难不成立，完毕循坏。

8．

#includ<stdio.h>

main

{intsum=10,n=1;

whiln<3

{sum=sum-n;

n++;}

printf%d,%d,n,sum;

运转后果为：3,7

当循环条件n<3建立的时分，中执行循坏体{sum=sum-n;n++;}中的语句。

循坏初值sum为10,n为1;

循坏基本条件n<3建立

第1次循环：中执行sum=sum-n=10-1=9

中执行n++,行将n中的值加1中执行后n为2

此时n中的值为2sum中的值为9循坏基本条件n<3建立，持续中执行循坏

第2次循环：中执行sum=sum-n=9-2=7

中执行n++,行将n中的值加1中执行后n为3

输入此时n,sum中的值，即为3,7需求留意，printf%d,%d,n,sum;中要求输出的数据相互间用逗号间隔，因而后果的两个数据间肯定要有逗号

#includ<stdio.h>

main

{intnum,c;

scanf”%d”,&num;

do{c=num%10;printf”%d”,c;}whilenum/=10>0;

printf”n”;

从键盘输入23则运转后果为：32

详见教材p117循坏构造；p60复合的赋值运算符

do{}while直接表达式;

先无条件中执行循坏体，再判别循坏基本条件。留意while直接表达式）后有分号

界说整型变量numc;

为num赋一个整型值；

中执行{c=num%10;printf”%d”,c;}直到循坏基本条件num/=10>0难不成立；

输入换行

已知为num赋值23

第1次中执行循坏体

中执行c=num%10=23%10=3;

中执行printf”%d”,c;输入3

判别循坏基本条件num/=10等价于num=num/10;因而num=23/10=2,2大于0因而循坏基本条件num/=10>0建立，持续中执行循坏体。中执行完第1次循环时，num为2c为3

第2次中执行循坏体

中执行c=2%10=2;

中执行printf”%d”,c;再输出2

判别循坏基本条件num=2/10=0,0即是0因而循坏基本条件num/=10>0难不成立。完毕循坏

#includ<stdio.h>

main

ints=0,a=5,n;

scanf”%d”,&n;

do{s+=1;a=a-2;}

whila!=n;

printf”%d%dn”,s,a;

若输入的值1运转后果为：2,1

详见教材p117循坏构造；p60复合的赋值运算符

中执行{s+=1;a=a-2;}直到循坏基本条件a!=n难不成立；

已知为n赋值1,s为0a为5

第1次中执行循坏体

中执行s+=1;等价于s=s+1=0+1

中执行a=a-2;a=5-2=3

判别循坏基本条件,3不等于1因而循坏基本条件a!=n建立,持续中执行循坏体。

中执行完第1次循环时，s为1a为3

第2次中执行循坏体

中执行s+=1;等价于s=s+1=1+1=2

中执行a=a-2;a=3-2=1

判别循坏基本条件,1即是1因而循坏基本条件a!=n难不成立,完毕循坏。

中执行完第2次循环时，s为2a为1

输入此时s,a中的值，后果为2,1

11．

#includ”stdio.h”

main

{charc;

c=getchar;

whilc!=\’?\’

{putcharc;

c=getchar;}

假如从键盘输入abcdefgh回车）

运转后果为：abcde

12．

#includ<stdio.h>

main

{charc;

whilec=getchar!=$

{ifA<=c&&c<=Zputcharc;

elsifa<=c&&c<=zputcharc-32;}

当输入为ab*A B%cd#CD$时，运转后果为：A BA BCDCD

13.

#includ<stdio.h>

main

{intx,y=0;

forx=1;x<=10;x++

{ify>=10

break;

y=y+x;

}

printf%d%d,y,x瀑布题材;

运转后果为105

详见教材p120for语句

详见教材p126~128breakcontinue语句

for直接表达式1;直接表达式2;直接表达式3

1先求解直接表达式1

2求解直接表达式2若其值为真，中执行循坏体，接着中执行3.若为假，则结束循环，转到5

3求解直接表达式3

4转回上面2持续中执行

5循坏完毕，中执行for语句上面的一个语句

break跳出循坏体；continue,完毕本次循坏（第i次循环）持续中执行下一次循环第i+1次循环

此题直接表达式1为x=1直接表达式2循坏基本条件）为x<=10直接表达式3为x++

初值x为1y为0循坏基本条件（即表达式2x<=10建立，进入循坏体

第1次循环

中执行if语句。0小于10if语句的基本条件直接表达式不成立，不执行break;

中执行y=y+x;y=0+1=1

转向直接表达式3中执行x++,x=x+1=1+1=2循坏基本条件x<=10建立，进入第2次循环

第2次循环

中执行if语句。1小于10if语句的基本条件直接表达式不成立，不执行break;

中执行y=y+x;y=1+2=3

转向直接表达式3中执行x++,x=x+1=2+1=3循坏基本条件x<=10建立，进入第3次循环

第3次循环

中执行if语句。3小于10if语句的基本条件直接表达式不成立，不执行break;

中执行y=y+x;y=3+3=6

转向直接表达式3中执行x++,x=x+1=3+1=4循坏基本条件x<=10建立，进入第4次循环

第4次循环

中执行if语句。6小于10if语句的基本条件直接表达式不成立，不执行break;

中执行y=y+x;y=6+4=10

转向直接表达式3中执行x++,x=x+1=4+1=5循坏基本条件x<=10建立，进入第5次循环

第5次循环

中执行if语句。10即是10if语句的基本条件直接表达式成立，中执行break跳出循坏。

从break跳出至for语句的下一条语句。中执行printf%d%d,y,x;

输入以后的y与x.后果为105

14.

#include<stdio.h>

main

{charch;

ch=getchar;

switchch

{caseA:printf%c,A;

caseB:printf%c,B;break;

default:printf%sn,other;

}}

当从键盘输出字母A时，运转后果为：A B

详见教材p103switch语句

switch直接表达式）

{case常量1语句1

case常量2语句2

┇┇┇

case常量n语句n

default:语句n+1

其中包括直接表达式，常量1常量n都为整型或字符型

case非常于给出执行程序的入口处和起始位置，若找到婚配的常量，则今后处开端往下执行程序，不再婚配常量，直至遇到break或switch完毕

本题过程：

先从键盘接纳一个字符A并将其放在变量ch中。

中执行switch语句。Switch前面的基本条件直接表达式为ch,因而直接表达式的值即为字符A.用字符A顺次与下面的case中的常量匹配。

与第1个case后的常量匹配，则从其后的语句开端往下执行程序（中执行进程中不再停止婚配。因而先执行printf%c,A屏幕上输出A 再往下继续执行printf%c,B屏幕上输出B再继续执行break此时跳出switch语句。

15.

#includ<stdio.h>

main

{inta=1,b=0

scanf%d,&a;

switcha

{case1:b=1break

cas2:b=2break

default:b=10}

printf”%d”,b

若键盘输入5运转后果为：10

本题过程：

先用scanf函数为变量a赋值为5

中执行switch语句。switch前面的基本条件直接表达式为a,因而直接表达式的值即为5.用5顺次与下面case中的常量匹配。也没找到婚配的常量，因而两个case后的语句都不执行。中执行default前面的语句b=10将10赋给变量b

输入变量b,后果为10

16.

#includ<stdio.h>

main_

{chargrade=C;

switchgrade

{

casA:printf90-100n;

caseB:printf80-90n;

casC:printf70-80n;

casD:printf60-70n;break;

casE:printf<60n;

default:printferror!n;

}

运转后果为

70-80

60-70

本题过程：

先从键盘接纳一个字符C并将其放在变量grade中。

中执行switch语句。switch前面的基本条件直接表达式为grade,因而直接表达式的值即为字符C.用字符C顺次与下面的case中的常量匹配。

与第3个case后的常量匹配，则从其后的语句开端往下执行程序（中执行进程中不再停止婚配。因而先执行printf70-80n;屏幕上输出70-80,并换行；再往下继续执行printf60-70n屏幕上输出60-70并换行；再继续执行break此时跳出switch语句。

17.

#includ<stdio.h>

main

{inty=9;

for;y>0;y–

ify%3==0

{printf%d,–y;

运转后果为

852

详见教材p53自增自减符号

此题直接表达式1被省略，直接表达式2循坏基本条件）为y>0直接表达式3为y–

初值y为9循坏基本条件（即表达式2y>0建立，进入循坏体

第1次循环

中执行if语句。9%3==0if语句的基本条件直接表达式成立，中执行printf%d,–y即y先自减1变成8接着在输入，因而屏幕上输出8

转向直接表达式3中执行y–,y=y-1=8-1=7循坏基本条件y>0建立，进入第2次循环

第2次循环

中执行if语句。7%3不为0if语句的基本条件直接表达式不成立，不执行printf%d,–y

转向直接表达式3中执行y–,y=y-1=7-1=6循坏基本条件y>0建立，进入第3次循环

第3次循环

中执行if语句。6%3==0if语句的基本条件直接表达式成立，中执行printf%d,–y即y先自减1变成5接着在输入，因而屏幕上输出5

转向直接表达式3中执行y–,y=y-1=5-1=4循坏基本条件y>0建立，进入第4次循环

第4次循环

中执行if语句。4%3不为0if语句的基本条件直接表达式不成立，不执行printf%d,–y

转向直接表达式3中执行y–,y=4-1=3循坏基本条件y>0建立，进入第5次循环

第5次循环

中执行if语句。3%3==0if语句的基本条件直接表达式成立，中执行printf%d,–y即y先自减1变成2接着在输入，因而屏幕上输出2

转向直接表达式3中执行y–,y=y-1=2-1=1循坏基本条件y>0建立，进入第5次循环

第6次循环

中执行if语句。1%3不为0if语句的基本条件直接表达式不成立，不执行printf%d,–y

转向直接表达式3中执行y–,y=1-1=0循坏基本条件y>0难不成立，循坏完毕。

18.

#includ<stdio.h>

main

{inti,sum=0;

i=1;

do{sum=sum+i;i++;}

whili<=10;

printf%d,sum;
}

运转后果为55

19.

#includ<stdio.h>

#definN4

main

{inti;

intx1=1,x2=2;

printf”n”;

fori=1;i<=N;i++

{printf”%4d%4d”,x1,x2;

ifi%2==0

printf”n”;

x1=x1+x2;

x2=x2+x1;

运转后果为

1235

8132134

此题首先为整型变量赋初值x1=1,x2=2

直接表达式1为i=1直接表达式2循坏基本条件）为i<=N即i<=4直接表达式3为i++

循坏变量初值i为1循坏基本条件（即表达式2i<=4建立，进入第1次循环

第1次循环

中执行printf”%4d%4d”,x1,x2;因而屏幕上输出12

中执行if语句。1%2不为0if语句的基本条件直接表达式不成立，不执行printf”n”;

中执行x1=x1+x2=1+2=3;此时x1中的值已变为3

中执行x2=x2+x1=2+3=5

转向直接表达式3中执行i++,i为2循坏基本条件i<=4建立，进入第2次循环

第2次循环

中执行printf”%4d%4d”,x1,x2;因而屏幕上输出35

中执行if语句。2%2==0if语句的基本条件直接表达式成立，中执行printf”n”;换行

中执行x1=x1+x2=3+5=8;此时x1中的值已变为8

中执行x2=x2+x1=5+8=13

转向直接表达式3中执行i++,i为3循坏基本条件i<=4建立，进入第3次循环

第3次循环

中执行printf”%4d%4d”,x1,x2;因而屏幕上输出813

中执行if语句。3%2不为0if语句的基本条件直接表达式不成立，不执行printf”n”;

中执行x1=x1+x2=8+13=21;此时x1中的值已变为21

中执行x2=x2+x1=21+13=34

转向直接表达式3中执行i++,i为4循坏基本条件i<=4建立，进入第4次循环

第2次循环

中执行printf”%4d%4d”,x1,x2;因而屏幕上输出2134

中执行if语句。4%2==0if语句的基本条件直接表达式成立，中执行printf”n”;换行

中执行x1=x1+x2=21+34=55;此时x1中的值已变为55

中执行x2=x2+x1=34+55=89

转向直接表达式3中执行i++,i为5循坏基本条件i<=4难不成立，完毕循坏

#includ<stdio.h>

main

{intx,y;

forx=30,y=0;x>=10,y<10;x–,y++

x/=2,y+=2;

printfx=%d,y=%dn,x,i;

运转后果为

x=0,y=12

21.

#includ<stdio.h>

#definN4

main

{inti,j;

fori=1;i<=N;i++

{forj=1;j<i;j++

printf””;

printf”*”;

printf”n”;}

运转后果为：

详见教材P41象征符号常量

用宏处置指令界说象征符号常量N为4编译进程中，遇到N即视为整数4

外层for循坏，直接表达式1为i=1直接表达式2循坏基本条件）为i<=N直接表达式3为i++

内层for循坏，直接表达式1为j=1直接表达式2循坏基本条件）为j<i直接表达式3为j++

先盘算外层循坏的直接表达式1i为1使得循坏基本条件i<=4建立，进入外层for循坏体

外层for循坏第1次此时i为1

内层循环j=1,使得循坏基本条件j<i难不成立，因而不中执行内层循环体（不输出空格）

中执行printf”*”;

中执行printf”n”;换行

至此外层循坏体执行完，盘算外层循坏的直接表达式3i++此时i为2.使得循坏基本条件i<=4

建立，再次进入外层for循坏体

外层for循坏第2次此时i为2

内层循环j=1,使得循坏基本条件j<i建立

第1次中执行内层循环体printf””;

中执行内层循坏直接表达式3j++为2j<i难不成立，跳出内层循环

中执行printf”*”;

中执行printf”n”;换行

至此外层循坏体执行完，盘算外层循坏的直接表达式3i++此时i为3.使得循坏基本条件i<=4

建立，进入外层for循坏体

外层for循坏第3次此时i为3

内层循环j=1,使得循坏基本条件j<i建立

第1次中执行内层循环体printf””;

中执行内层循坏直接表达式3j++为2j<i建立，再次中执行内层循环

第2次中执行内层循环体printf””;

中执行内层循坏直接表达式3j++为3j<i难不成立，跳出内层循环

中执行printf”*”;

中执行printf”n”;换行

至此外层循坏体执行完，盘算外层循坏的直接表达式3i++此时i为4.使得循坏基本条件i<=4

建立，进入外层for循坏体

外层for循坏第4次此时i为4

内层循环j=1,使得循坏基本条件j<i建立

第1次中执行内层循环体printf””;

中执行内层循坏直接表达式3j++为2j<i建立，再次中执行内层循环

第2次中执行内层循环体printf””;

中执行内层循坏直接表达式3j++为3j<i建立，再次中执行内层循环

第3次中执行内层循环体printf””;

中执行内层循坏直接表达式3j++为4j<i难不成立，跳出内层循环

中执行printf”*”;

中执行printf”n”;换行

至此外层循坏体执行完，盘算外层循坏的直接表达式3i++此时i为5.使得循坏基本条件i<=4

难不成立，跳出外层for循坏体

#includ<stdio.h>

main

{inti,a[10];

fori=9;i>=0;i–

a[i]=10-i;

printf%d%d%d,a[2],a[5],a[8];

运转后果为：

852

详见p143-146.例题6.1肯定看懂！

先界说整型变量i整型数组a,a长度为10即a中包含10个整型元素（整型变量）

中执行for循坏语句

初值i=9,使得循坏基本条件i>=0建立，中执行循坏体

第1次循环

中执行a[i]=10-i等价于a[9]=10-9=1

盘算直接表达式3即i–i为8使得循坏基本条件i>=0建立，持续中执行循坏体

第2次循环

中执行a[i]=10-i等价于a[8]=10-8=2

盘算直接表达式3即i–i为7使得循坏基本条件i>=0建立，持续中执行循坏体

第3次循环

中执行a[i]=10-i等价于a[7]=10-7=3

盘算直接表达式3即i–i为6使得循坏基本条件i>=0建立，持续中执行循坏体

第4次循环

中执行a[i]=10-i等价于a[6]=10-6=4

盘算直接表达式3即i–i为5使得循坏基本条件i>=0建立，持续中执行循坏体

第5次循环

中执行a[i]=10-i等价于a[5]=10-5=5

盘算直接表达式3即i–i为4使得循坏基本条件i>=0建立，持续中执行循坏体

第6次循环

中执行a[i]=10-i等价于a[4]=10-4=6

盘算直接表达式3即i–i为3使得循坏基本条件i>=0建立，持续中执行循坏体

第7次循环

中执行a[i]=10-i等价于a[3]=10-3=7

盘算直接表达式3即i–i为2使得循坏基本条件i>=0建立，持续中执行循坏体

第8次循环

中执行a[i]=10-i等价于a[2]=10-2=8

盘算直接表达式3即i–i为1使得循坏基本条件i>=0建立，持续中执行循坏体

第9次循环

中执行a[i]=10-i等价于a[1]=10-1=9

盘算直接表达式3即i–i为0使得循坏基本条件i>=0建立，持续中执行循坏体

第10次循环

中执行a[i]=10-i等价于a[0]=10-0=10

盘算直接表达式3即i–i为-1使得循坏基本条件i>=0难不成立，跳出循坏体

2.

#includ<stdio.h>

main

{inti,a[6];

fori=0;i<6;i++

a[i]=i;

fori=5;i>=0;i–

printf”%3d”,a[i];

运转后果为：

543210

先界说整型变量i整型数组a,a长度为6即a中包含6个整型元素（整型变量）

中执行第一个for循坏语句

初值i=0,使得循坏基本条件i<6建立，中执行循坏体

第1次循环

中执行a[i]=i等价于a[0]=0

盘算直接表达式3即i++i为1使得循坏基本条件i<6建立，持续中执行循坏体

第2次循环

中执行a[i]=i等价于a[1]=1

盘算直接表达式3即i++i为2使得循坏基本条件i<6建立，持续中执行循坏体

第3次循环

中执行a[i]=i等价于a[2]=2

盘算直接表达式3即i++i为3使得循坏基本条件i<6建立，持续中执行循坏体

第4次循环

中执行a[i]=i等价于a[3]=3

盘算直接表达式3即i++i为4使得循坏基本条件i<6建立，持续中执行循坏体

第5次循环

中执行a[i]=i等价于a[4]=4

盘算直接表达式3即i++i为5使得循坏基本条件i<6建立，持续中执行循坏体

第6次循环

中执行a[i]=i等价于a[5]=5

盘算直接表达式3即i++i为6使得循坏基本条件i<6难不成立，完毕循坏

中执行第二个for循坏语句

初值i=5,使得循坏基本条件i>=0建立，中执行循坏体

第1次循环

中执行printf”%3d”,a[i];即输出a[5]值

盘算直接表达式3即i–i为4使得循坏基本条件i>=0建立，持续中执行循坏体

第2次循环

中执行printf”%3d”,a[i];即输出a[4]值

盘算直接表达式3即i–i为3使得循坏基本条件i>=0建立，持续中执行循坏体

第3次循环

中执行printf”%3d”,a[i];即输出a[3]值

盘算直接表达式3即i–i为2使得循坏基本条件i>=0建立，持续中执行循坏体

第4次循环

中执行printf”%3d”,a[i];即输出a[2]值

盘算直接表达式3即i–i为1使得循坏基本条件i>=0建立，持续中执行循坏体

第5次循环

中执行printf”%3d”,a[i];即输出a[1]值

盘算直接表达式3即i–i为0使得循坏基本条件i>=0建立，持续中执行循坏体

第6次循环

中执行printf”%3d”,a[i];即输出a[0]值

盘算直接表达式3即i–i为6使得循坏基本条件i>=0难不成立，完毕循坏

3.

#includ<stdio.h>

main

{inti,k=5,a[10],p[3]

fori=0i<10i++

a[i]=i

fori=0i<3i++

p[i]=a[i*i+1]

fori=0i<3i++

k+=p[i]*2

printf”%dn”,k

运转后果为21

先界说整型变量ik整型数组a,a长度为10整型数组p,p长度为3

k初值为5

第一个for循坏语句为数组a停止初始化

中执行完第一个for语句后，a[0]=0a[1]=1a[2]=2a[3]=3a[4]=4a[5]=5a[6]=6a[7]=7a[8]=8a[9]=9循坏进程略）

第二个for循坏语句为数组p停止初始化

初值i=0,使得循坏基本条件i<3建立，中执行循坏体

第1次循环

中执行p[i]=a[i*i+1];即p[0]=a[0*0+1]=a[0]=0

盘算直接表达式3即i++i为1使得循坏基本条件i<3建立，持续中执行循坏体

第2次循环

中执行p[i]=a[i*i+1];即p[1]=a[1*1+1]=a[2]=2

盘算直接表达式3即i++i为2使得循坏基本条件i<3建立，持续中执行循坏体

第3次循环

中执行p[i]=a[i*i+1];即p[2]=a[2*2+1]=a[6]=6

盘算直接表达式3即i++i为3使得循坏基本条件i<3难不成立，完毕循坏

第三个for循坏语句

初值i=0,使得循坏基本条件i<3建立，中执行循坏体

第1次循环

中执行k+=p[i]*2;即k=5+p[0]*2=5+0=5

盘算直接表达式3即i++i为1使得循坏基本条件i<3建立，持续中执行循坏体

第2次循环

中执行k+=p[i]*2;即k=5+p[1]*2=5+2*2=9

盘算直接表达式3即i++i为2使得循坏基本条件i<3建立，持续中执行循坏体

第1次循环

中执行k+=p[i]*2;即k=9+p[2]*2=9+6*2=21

盘算直接表达式3即i++i为3使得循坏基本条件i<3难不成立，完毕循坏

#includ<stdio.h>

intm[3][3]={{1},{2},{3}};

intn[3][3]={1,2,3};

main

{printf%d,,m[1][0]+n[0][0];

printf%dn,m[0][1]+n[1][0];

运转后果为

3,0

详见教材P149~152图6.7看懂！

先界说整型二维数组mm为3行，3列的二维矩阵，并对其以行的方式初始化

m[0][0]=1m[0][1]=0m[1][2]=0

m[1][0]=2m[1][1]=0m[2][2]=0

m[2][0]=3m[2][1]=0m[2][2]=0

界说整型二维数组nm为3行，3列的二维矩阵

n[0][0]=1n[0][1]=2n[1][2]=3

n[1][0]=0n[1][1]=0n[2][2]=0

n[2][0]=0n[2][1]=0n[2][2]=0

因而m[1][0]+n[0][0]=2+1=3

m[0][1]+n[1][0]=0+0=0

#includ<stdio.h>

main

{inti;

intx[3][3]={1,2,3,4,5,6,7,8,9};

fori=1;i<3;i++

printf”%d”,x[i][3-i];

}

运转后果为

68

先按存储先后顺序为数组x初始化

x[0][0]=1x[0][1]=2x[0][2]=3

x[1][0]=4x[1][1]=5x[1][2]=6

x[2][0]=7x[2][1]=8x[2][2]=9

初值i=1,使得循坏基本条件i<3建立，中执行循坏体

第1次循环

中执行printf”%d”,x[i][3-i]打印出x[i][3-i]即x[1][2]值

盘算直接表达式3即i++i为2使得循坏基本条件i<3建立，持续中执行循坏体

第2次循环

中执行printf”%d”,x[i][3-i]打印出x[i][3-i]即x[2][1]值

盘算直接表达式3即i++i为3使得循坏基本条件i<3建立，完毕循坏

#includ<stdio.h>

main

{intn[3][3],i,j

fori=0i<3i++

{forj=0j<3j++

{n[i][j]=i+j

printf%d,n[i][j]

运转后果为

012

123

234

循坏变量i为0,循坏基本条件i<3建立，中执行循坏体

外层for第1次循环非常于输出第1行

内层for循坏j初值为0循坏基本条件j<3建立，中执行循坏体

内层for第1次循环

中执行n[i][j]=i+j即n[0][0]=0+0=0

中执行printf%d,n[i][j]

中执行内层循坏直接表达式3j++j为1j<3建立，持续中执行内层循环体

内层for第2次循环

中执行n[i][j]=i+j即n[0][1]=0+1=1

中执行printf%d,n[i][j]

中执行内层循坏直接表达式3j++j为2j<3建立，持续中执行内层循环体

内层for第3次循环

中执行n[i][j]=i+j即n[0][2]=0+2=2

中执行printf%d,n[i][j]

中执行内层循坏直接表达式3j++j为3j<3不建立，完毕内层循环

中执行printfn;

外层for第2次循环非常于输出第2行

内层for循坏j初值为0循坏基本条件j<3建立，中执行循坏体

内层for第1次循环

中执行n[i][j]=i+j即n[1][0]=1+0=1

中执行printf%d,n[i][j]

中执行内层循坏直接表达式3j++j为1j<3建立，持续中执行内层循环体

内层for第2次循环

中执行n[i][j]=i+j即n[1][1]=1+1=2

中执行printf%d,n[i][j]

中执行内层循坏直接表达式3j++j为2j<3建立，持续中执行内层循环体

内层for第3次循环

中执行n[i][j]=i+j即n[1][2]=1+2=3

中执行printf%d,n[i][j]

中执行内层循坏直接表达式3j++j为3j<3不建立，完毕内层循环

中执行printfn;

外层for第2次循环非常于输出第3行

内层for循坏j初值为0循坏基本条件j<3建立，中执行循坏体

内层for第1次循环

中执行n[i][j]=i+j即n[2][0]=2+0=1

中执行printf%d,n[i][j]

中执行内层循坏直接表达式3j++j为1j<3建立，持续中执行内层循环体

内层for第2次循环

中执行n[i][j]=i+j即n[2][1]=2+1=2

中执行printf%d,n[i][j]

中执行内层循坏直接表达式3j++j为2j<3建立，持续中执行内层循环体

内层for第3次循环

中执行n[i][j]=i+j即n[2][2]=2+2=3

中执行内层循坏直接表达式3j++j为3j<3不建立，完毕内层循环

中执行printfn;

中执行外层for语句的直接表达式3i++i为,3i<3难不成立，完毕外层循坏

7．

#includ<stdio.h>

main

chardiamond[][5]={{_,_,*},{_,*,_,*},

{*,_,_,_,*},{_,*,_,*},{_,_,*}};

inti,j;

fori=0;i<5;i++

forj=0;j<5;j++

printf%c,diamond[i][j];

printfn;

}注：_代表一个空格。

运转后果为：

**

**

**

#includ<stdio.h>

main

{inti,f[10];

f[0]=f[1]=1;

fori=2;i<10;i++

f[i]=f[i-2]+f[i-1];

fori=0;i<10;i++

{ifi%4==0

printfn;

printf%d,f[i];

}

运转后果为

1123

581321

3455

9．

#includstdio.h

funcintb[]

{intj;

forj=0;j<4;j++

b[j]=j;

}

main

{inta[4],i;

funca;

fori=0;i<4;i++

printf%2d,a[i];

运转后果为：

0123

详见教材P194

界说函数func

函数头：还未定义函数的不同类型，则零碎默许为int型。函数func形参为整型数组名，即只接纳整型数组地址。

函数体：界说整型变量j

循坏变量初值（直接表达式1j=0,使得循坏基本条件（直接表达式2j<4建立，中执行循坏体

第1次循环

中执行b[j]=j;即b[0]=0;

中执行循坏变量自增（及表达式3j++j为1使得j<4建立，持续中执行循坏体

第2次循环

b[1]=1

j++j为2使得j<4建立，持续中执行循坏体

第3次循环

b[2]=2

j++j为3使得j<4建立，持续中执行循坏体

第4次循环

b[3]=3

j++j为4使得j<4难不成立，完毕循坏

main函数：

界说整型变量i和数组a其长度为4

funca;表现挪用函数func并以数组名a作为挪用的实参（数组名在C言语中表现数组所在内存空间的首地址，以数组名作为实参时，形到场实参共用存储空间，因而对数组b操作方式，即对数组a操作方式。

10.

#includ<stdio.h>

main

{floatfunfloatx[]

floatave,a[3]={4.524}

ave=funa;

printfave=%7.2f,ave;

floatfunfloatx[]

{intj;

floataver=1

forj=0;j<3;j++

aver=x[j]*aver;

returnaver

运转后果为：

ave=36.00

11.

#includ<stdio.h>

main

{inta[2][3]={{1,2,3},{4,5,6}};

intb[3][2],i,j;

fori=0;i<=1;i++

{forj=0;j<=2;j++

b[j][i]=a[i][j];

fori=0;i<=2;i++

{forj=0;j<=1;j++

printf”%5d”,b[i][j];

运转后果为

142536

12．

#includ<stdio.h>

fintb[],intn

{inti,r;

r=1;

fori=0;i<=n;i++

r=r*b[i];

returnr;

main

{intx,a[]={1,2,3,4,5,6,7,8,9};

x=fa,3;

printf%dn,x;

运转后果为

24

13.

#include”stdio.h”

main

{intj,k;

staticintx[4][4],y[4][4];

forj=0;j<4;j++

fork=j;k<4;k++

x[j][k]=j+k;

forj=0;j<4;j++

fork=j;k<4;k++

y[k][j]=x[j][k];

forj=0;j<4;j++

fork=0;k<4;k++

printf”%d,”,y[j][k];

运转后果为

0,0,0,0,1,2,0,0,2,3,4,0,3,4,5,6

#includ<stdio.h>

intSubinta,intb

{returna-b;}

main

{intx,y,result=0;

scanf”%d,%d”,&x,&i;

result=Subx,y;

printf”result=%dn”,result;

当从键盘输入:6,3运转后果为

result=3

2.

#includ<stdio.h>

intminintx,inty

{intm

ifx>ym=x

elsm=y

returnm

｝

main{

inta=3,b=5,abmin

abmin=mina,b

printfminis%dabmin

运转后果为：

minis5

#include<stdio.h>

funcintx{

x=10;

printf%d,,x;

main

{intx=20;

funcx;

printf%d,x;

运转后果为：

10,20

main函数中调用函数funcmain函数将20作为实参穿给func并转向开端中执行func.

main对应的内存func对应的内存

20x

20x

func中执行x=10;其内存中x变成10.

10x

func中执行printf%d,,x;即输出func函数对应内存中x值，输入的10.至此，func函数中执行完毕，前往main函数。

main函数中执行printf%d,x;此时输入main函数对应内存中的x即20

#includ<stdio.h>

intm=4;

intfuncintx,inty

{intm=1;

returnx*y-m;

main

{inta=2,b=3;

printf”%dn”,m;

printf”%dn”,funca,b/m;

运转后果为

整型变量m函数外定义，因而m为全局变量，其起到于规模为其界说地位开端，不断到整体顺序完毕。因而func与main函数都可以访问m

顺序先中执行main函数

中执行printf”%dn”,m;即输出m中的值4并换行。

需求挪用函数func此时main将a,b中的2和3值作为实参传递给funcx和y

顺序开端转向中执行func函数，此时func中的x为2y为3

中执行intm=1;此句定义了一个局部变量m并赋值为1m起到域为其所在复合

语句，即func函数体，因而在func函数体重，无限拜访部分变量m

中执行returnx*y-m;即return2*3-1;前往的整数5.

func函数前往至main函数中的被调用处

main函数中funca,b值为5funca,b/m=5/4=1,留意，main函数中访问的m为全局变量m此时main函数难以拜访func中的m由于不在func中m起到域。

#includ<stdio.h>

intfuninta,intb

{ifa>breturna;

elsreturnb;

main

{intx=15,y=8,r;

r=funx,y;

printf”r=%dn”,r;

运转后果为r=15

顺序先中执行main函数

中执行r=funx,y;行将funcx,y值赋给r为了盘算该表达式，需求挪用函数func此时main将x,y中的15和8值作为实参传递给funca和b

顺序开端转向中执行func函数，此时func中的a为15b为8

中执行if语句;判别if前面的直接表达式，a>b建立，因而中执行响应的操作方式returna即返回

a值

func函数前往至main函数中的被调用处

main函数中funcx,y值为15行将15赋给r

中执行printf”r=%dn”,r;即输出r=15

#includ<stdio.h>

intfacintn

{intf=1,i;

fori=1;i<=n;i++

f=f*i;

returnf;

main

{intj,s;

scanf%d,&j;

s=facj;

printf”%d!=%dn”,j,;

假如从键盘输入3运转后果为：3!=6

顺序先中执行main函数

中执行r=funx,y;行将funcx,y值赋给r为了盘算该表达式，需求挪用函数func此时main将x,y中的15和8值作为实参传递给funca和b

顺序开端转向中执行func函数，此时func中的a为15b为8

中执行if语句;判别if前面的直接表达式，a>b建立，因而中执行响应的操作方式returna即返回

a值

func函数前往至main函数中的被调用处

main函数中funcx,y值为15行将15赋给r

中执行printf”r=%dn”,r;即输出r=15

7.

#includ<stdio.h>

unsignfun6unsignnum

{unsignk=1;

do

{k*=num%10;

num/=10;

}whilnum;

returnk;

main

{unsignn=26;

printf%dn,fun6n;

运转后果为12

顺序先中执行main函数

中执行printf%dn,fun6n;即输入直接表达式func6值，为了盘算该表达式，需求挪用

函数func此时main将n中的26作为实参传递给funcnum

顺序开端转向中执行func函数，此时func中的num为26

中执行do-while语句

第1次循环

中执行k*=num%10,即k=k*num%10=1*26%10=6

中执行num/=10;即num=num/10=26/10=2

while前面循坏基本条件为num,此时num为2非0值，即表现循坏基本条件建立，

持续中执行循坏体。此时k为6

第2次循环

中执行k*=num%10,即k=k*num%10=6*2%10=12

中执行num/=10;即num=num/10=2/10=0

while前面循坏基本条件为num,此时num为0表现循坏基本条件难不成立，

完毕循坏

中执行returnk;即返回至main函数中的被调用处

中执行main函数

持续中执行printf%dn,fun6n;即输出12

#includ<stdio.h>

intmaxintx,inty;

main

{inta,b,c;

a=7;b=8;

c=maxa,b;

printf”Maxis%d”,c;

maxintx,inty

{intz;

z=x>y?x:y;

returnz;

运转后果为：

Maxis8

#includ<stdio.h>

main

{intx[]={10,20,30,40,50};

int*p;

p=x;

printf%d,*p+2;

运转后果为

先界说一个整型数组xx长度为5;接着界说一个指针变量p;对p停止初始化，将数组x餐厅地址赋给p因而此时p中存放的数组x首地址，即数组中第一个元素x[0]餐厅地址。

接着中执行printf语句，输入直接表达式*p+2值。p+2表现以p以后指向的地位初始，后第2个元素的餐厅地址，即a[2]餐厅地址。*p+2则表现该地址内所存放的其他内容，即a[2]值30,因而输入30

#includ<stdio.h>

main

{chars[]=abcdefg;

char*p;

p=s;

printfch=%cn,*p+5;

运转后果为

ch=f

先界说一个字符型数组s并用字符串abcdefg对s停止初始化;接着界说一个字符型指针变量p;对p停止初始化，将数组s餐厅地址赋给p因而此时p中存放的数组s首地址，即数组中第一个元素s[0]餐厅地址。

接着中执行printf语句，输入直接表达式*p+5值。p+5表现以p以后指向的地位初始，后第5个元素的餐厅地址，即a[5]餐厅地址。*p+5则表现该地址内所存放的其他内容，即a[5]值f,因而输入ch=f

#include<stdio.h>

main

{inta[]={1,2,3,4,5}

intx,y,*p

p=a

x=*p+2

printf”%d%dn”,*p,x

运转后果为:

1:3

先界说一个整型数组a并对a停止初始化;接着界说整型变量x,y整型指针变量p;再将数组a餐厅地址赋给p因而此时p中存放的数组a首地址，即数组中第一个元素a[0]餐厅地址。中执行x=*p+2p+2表现以p以后所指向的地位初始，后第2个元素的餐厅地址，即a[2]餐厅地址。*p+2则表现该地址内所存放的其他内容，即a[2]值3接着再把3赋给x

接着中执行printf语句，先输入直接表达式*p值。此时*p表现的p所指向变量的其他内容，即a[0]值1再输入一个冒号。接着再输出x中的值3

#include<stdio.h>

main

{intarr[]={30,25,20,15,10,5},*p=arr;

p++;

printf%dn,*p+3;

运转后果为10

先界说一个整型数组arr并对arr停止初始化;接着界说整型指针变量p;再将数组arr餐厅地址赋给p因而此时p中存放的数组arr首地址，即数组中第一个元素a[0]餐厅地址。

中执行p++即p=p+1p+1表现以p以后所指向的地位初始，后第1个元素的餐厅地址，即arr[1]餐厅地址，接着再将arr[1]餐厅地址赋给p中执行完此语句后，p不再指向arr[0]而是指向arr[1]

接着中执行printf语句，输入直接表达式*p+3值。p+3表现以p以后指向的地位初始此时p指向arr[1]后第3个元素的餐厅地址，即arr[4]餐厅地址。*p+3则表现该地址内所存放的其他内容，即arr[4]值10,因而输入10

#includ<stdio.h>

main

{inta[]={1,2,3,4,5,6};

intx,y,*p;

p=&a[0];

x=*p+2;

y=*p+4;

printf*p=%d,x=%d,y=%dn,*p,x,y;

运转后果为

*p=1,x=3,y=5

先界说一个整型数组a并对a停止初始化;接着界说整型变量x,y整型指针变量p;再将数组元素a[0]餐厅地址赋给p

中执行x=*p+2p+2表现以p以后所指向的地位初始，后第2个元素的餐厅地址，即a[2]餐厅地址。*p+2则表现该地址内所存放的其他内容，即a[2]值3接着再把3赋给x

中执行i=*p+4;p+4表现以p以后所指向的地位初始，后第4个元素的餐厅地址，即a[4]餐厅地址。*p+4则表现该地址内所存放的其他内容，即a[4]值5接着再把5赋给y

中执行printf语句，先输入直接表达式*p值。此时*p表现的p所指向变量的其他内容，即a[0]值1再输x值3再输出y值5

#include<stdio.h>

main

{staticchara[]=Program,*ptr;

forptr=a,ptr<a+7;ptr+=2

putchar*ptr;

运转后果为

Porm

先界说一个字符型数组a并对a停止初始化;接着界说字符型指针变量p;

中执行for语句ptr=a为表达式1将数字a餐厅地址赋给ptr直接表达式2循坏基本条件）ptr<a+7直接表达式3为ptr+=2即ptr=ptr+2

第1次中执行循坏体

中执行putchar*ptr;即输出*ptr所对应的字符。此时ptr指向数组中的第1个元素，即

a[0],因而*ptr表现a[0]中的值，即P.

中执行完循环体，转向中执行直接表达式3即ptr=ptr+2ptr+2表现以ptr以后所指向的位

置起始，后第2个元素的餐厅地址,即a[2]餐厅地址，接着将a[2]餐厅地址赋给ptra[2]地

址等价于a+2因而循坏基本条件ptr<a+7建立，持续中执行循坏体

第2次中执行循坏体

中执行putchar*ptr;即输出*ptr所对应的字符。此时ptr指向数组中的第3个元素，即

a[2],因而*ptr表现a[2]中的值，即o.

中执行完循环体，转向中执行直接表达式3即ptr=ptr+2ptr+2表现以ptr以后所指向的位

置起始，后第2个元素的餐厅地址,即a[4]餐厅地址，接着将a[4]餐厅地址赋给ptra[4]地

址等价于a+4因而循坏基本条件ptr<a+7即a+4<a+7建立，持续中执行循坏体

第3次中执行循坏体

中执行putchar*ptr;即输出*ptr所对应的字符。此时ptr指向数组中的第5个元素，即

a[4],因而*ptr表现a[4]中的值，即r.

中执行完循环体，转向中执行直接表达式3即ptr=ptr+2ptr+2表现以ptr以后所指向的位

置起始，后第2个元素的餐厅地址,即a[6]餐厅地址，接着将a[6]餐厅地址赋给ptra[6]餐厅地址等价于a+6因而循坏基本条件ptr<a+7即a+6<a+7建立，持续中执行循坏体

第4次中执行循坏体

中执行putchar*ptr;即输出*ptr所对应的字符。此时ptr指向数组中的第7个元素，即

a[6],因而*ptr表现a[6]中的值，即m.

中执行完循环体，转向中执行直接表达式3即ptr=ptr+2ptr+2表现以ptr以后所指向的位

置起始，后第2个元素的餐厅地址,即a[8]餐厅地址，接着将a[8]餐厅地址赋给ptra[6]餐厅地址等价于a+8因而循坏基本条件ptr<a+7即a+8<a+7难不成立，完毕循坏。

#includ<stdio.h>

chars[]=ABCD;

main

{char*p;

forp=s;p<s+4;p++

printf%c%sn,*p,p;

运转后果为

A ABCD

BBCD

CCD

DD

先界说一个字符型数组s并对s停止初始化;数组s全局变量，其无效规模从其界说开端至整体顺序完毕。

中执行main函数

界说一个字符型指针p

中执行for语句p=s为表达式1将数字s首地址赋给p直接表达式2循坏基本条件）p<s+4直接表达式3为p++即p=p+1

第1次中执行循坏体

中执行printf%c%sn,*p,p;即以字符%c方式输入*p所对应的字符。此时p指

向数组中的第1个元素，即s[0],因而*p表现a[0]中的值，即A.接着再以字

符串%s方式输入以p中餐厅地址为首餐厅地址的整体字符串，即输出A BCD

中执行完循环体，转向中执行直接表达式3即p=p+1p+1表现以p以后所指向的

地位初始，后1个元素的餐厅地址,即s[1]餐厅地址，接着将a[1]餐厅地址赋给p

s[1]餐厅地址等价于s+1因而循坏基本条件p<s+4建立，持续中执行循坏体

第2次中执行循坏体

中执行printf%c%sn,*p,p;即以字符%c方式输入*p所对应的字符。此时p指

向数组中的第2个元素，即s[1],因而*p表现s[1]中的值，即B.接着再以字

符串%s方式输入以p中餐厅地址为首餐厅地址的整体字符串，此时p指向s[1]即

从s[1]开端，顺次输入前面的字符串，因而又输出BCD

中执行完循环体，转向中执行直接表达式3即p=p+1p+1表现以p以后所指向的

地位初始，后1个元素的餐厅地址,即s[2]餐厅地址，接着将a[2]餐厅地址赋给p

s[2]餐厅地址等价于s+2因而循坏基本条件p<s+4建立，持续中执行循坏体

第3次中执行循坏体

中执行printf%c%sn,*p,p;即以字符%c方式输入*p所对应的字符。此时p指

向数组中的第3个元素，即s[2],因而*p表现s[2]中的值，即C.接着再以字

符串%s方式输入以p中餐厅地址为首餐厅地址的整体字符串，此时p指向s[2]即

从s[2]开端，顺次输入前面的字符串，因而又输出CD

中执行完循环体，转向中执行直接表达式3即p=p+1p+1表现以p以后所指向的

地位初始，后1个元素的餐厅地址,即s[2]餐厅地址，接着将s[2]餐厅地址赋给p

s[2]餐厅地址等价于s+3因而循坏基本条件p<s+4建立，持续中执行循坏体

第4次中执行循坏体

中执行printf%c%sn,*p,p;即以字符%c方式输入*p所对应的字符。此时p指

向数组中的第4个元素，即s[3],因而*p表现s[3]中的值，即D.接着再以字

符串%s方式输入以p中餐厅地址为首餐厅地址的整体字符串，即输出D

中执行完循环体，转向中执行直接表达式3即p=p+1p+1表现以p以后所指向的

地位初始，后1个元素的餐厅地址,即s[3]餐厅地址，接着将s[3]餐厅地址赋给p

s[3]餐厅地址等价于s+4因而循坏基本条件p<s+4难不成立，完毕循坏

构造体

#include<stdio.h>

structst

{intx;

inty;

}a[2]={5,7,2,9};

main

printf”%dn”,a[0].y作文题材*a[1].x;

运转后果是

先是界说构造体stst中共有两个整型成员xy

接着界说一个st不同类型的数组aa长度为2即数组中含有两个st不同类型的元素，辨别是a[0]和a[1].对a停止初始化，此题是依照贮存先后顺序停止初始化，行将5赋给a[0]中的x即a[0].x=5;将7赋给a[0]中的y即a[0].y=7;将2赋给a[1]中的x即a[1].x=2;将9赋给a[1]中的y即a[1].y=9;

中执行main函数，输入直接表达式a[0].y*a[1].x值，即7*2值

5a[0].xa[0]

7a[0].i

2a[1].xa[1]

9a[1].y

#include<stdio.h>

main

{structstu

{intnum;

chara[5];

floatscore;

}m={1234,wang,89.5};

printf%d,%s,%f,m.num,m.a,m.scor;

运转后果是

1234,wang,89.5

#include<stdio.h>

structcmplx

{intx;

inty;

}cnum[2]={1,3,2,7};

main

{

printf%dn,cnum[0].i*cnum[1].x;

运转后果是6

与第一题解法同

#includ<stdio.h>

structabc

{inta,b,c;};

main

{structabcs[2]={{1,2,3},{4,5,6}};

intt;

t=s[0].a+s[1].b;

printf”%dn”,t;

运转后果是6

与第一题解法同

• 顺序填空

1．输出一个字符，判别该字符是数字、字母、空格还是其他字符。

main

{charch;

ch=getchar;

ifch>=a&&ch<=z||ch>=A&&ch<=Z

printf”ItisanEnglishcharactern”;

elsifch>=0&&ch<=9

printf”Itisadigitcharactern”;

elsifch==

printf”Itisaspacecharactern”;

els

printf”Itisothercharactern”;}

第1空：字符在盘算机中以A SCII码的方式存储。以是当输入的字符，即ch中字符所对应的A SCII码的规模在英文字母的A SCII码的规模内学生题材即可，参照p377因为英那些文字母又分为小写字母和小写字母，因而此处用一个逻辑或表达式，表现ch中是大写字母字母或许小写字母，都能使得直接表达式成立。ch>=97&&ch<=122||ch>=65&&ch<=90

需求留意的关于本题区间所对应的直接表达式，不行写作97<=ch<=122也不可写作A<=ch<=Z.关于97<=ch<=122由于在盘算此表达式时的先后顺序是从左向右，因而先计算97<=ch不论ch中的取值如何，直接表达式97<=ch值只要两种情况：0或1.以是不论是0还是1都小于122因而97<=ch<=122恒成立。

第3空，判别ch中是否为空格，也是经过ch中字符与空格字符的A SCII码来判断。判别直接表达式的值是否相等时，用关系符号==不要用赋值符号=

2．下列程序的功用是从输入的整数中，统计大于零的整数个数和小于零的整数个数。用输入0来结束输入，用i,j来放统计数，请填空完成程序。

voidmain

{intn,i=0,j=0;

printfinputainteger,0forendn;

scanf%d,&n;

whilen或n!=0{

ifn>0i=i+1;

elsj=j+1;

printfi=%4d,j=%4dn,i,j;

此题用i来记载大于零的整数，用j记载小于零的整数。以是循坏基本条件是n或许n!=0即当n不为0时中执行循坏体。循坏体中是一个选择语句。假如n>0则令i加1非常于令正整数的个数加1否者（即n<0,令j加1非常于令负整数的个数加1

3．编程计算1＋3＋5+＋101值

#includ<stdio.h>

voidmain

{inti,sum=0;

fori=1;i<=101;i=i+2;

sum=sum+i;

printf”sum=%dn”,sum;}

for语句的普通方式详见p120.

直接表达式1为i=1为循坏变量赋初值，即循环从1开端，本题从1101因而终值是101直接表达式2循坏基本条件，用来控制循环的完毕，因而循坏基本条件为i<=101直接表达式3为循环变量的自增，本题是

4．编程计算1＋3＋5＋99值

main

{inti,sum=0;

i=1;

whili<100

{sum=sum+i;

I=i+2;}

printf”sum=%dn”,sum;

5．从键盘输出一个字符，判别它否是英文字母。

#includ<stdio.h>

voidmain

{charc;

printf”inputacharacter:”;

c=getchar;

ifc>=A&&c<=Z||c>=a&&c<=zprintf”Yesn”;

elsprintf”No”;

6.上面顺序的功用是a数组中查找与x值相同的元素所在地位,请填空。

#includ<stdio.h>

voidmain

{inta[10],i,x;

printfinput10integ;

fori=0;i<10;i++

scanf%d,&a[i];

printfinputthenumberyouwanttofindx;

scanf%d,&x;

fori=0;i<10;i++

ifx==a[i]

break;

ifi<10

printfthepoofxis%dn,i;

elsprintfcannotfindxn;

7．程序读入20个整数，统计非负数个数，并盘算非负数之和小说题材。

#includ<stdio.h>

main

{inti,a[20],s,count;

s=count=0;

fori=0;i<20;i++

scanf%d,&a[i];

fori=0;i<20;i++

{ifa[i]<0continu;

s+=a[i];

count++;

printfs=%dtcount=%dn,s,count;

8.输出一个正整数n1<n≤10再输入n个整数，用选择法将它从小到大排序后输出。

#includ<stdio.h>

intmainvoid{

inti,index,k,n,temp;

/*界说1个数组a有10个整型元素*/

printfEntern:”;

printfEnter%dintegers:”,n;

fori=0;i<n;i++

scanf”%d”,&a[i];

fork=0;k<n-1;k++{/*对n个数排序 */

index=k;

for

ifindex=i;

printf”A ftersorted:”;

fori=0;i<n;i++/*输入n个数组元素的值 */

return0;}

• 顺序改错

一、上面每一顺序的划线处有语法或逻辑错误，请找出并改正，使其得到契合题意的中执行后果。

１．求1234n

main

{longintsum;//若定义变量的语句有错误，罕见考点有两个：1变量的不同类型，2界说用于寄存运算后果的变量时，肯定要赋初值。普通赋值0或许循坏初值。

intn,i=1;

scanf”%d”,n;//若scanf语句有错误，罕见考点有两个：1花样官方声明象征符号要与前面欲赋值的变量的不同类型分歧，此题%d与n不同类型int分歧（详见p69-782变量的后面要有地址符号&

printfn;

whili<n//循坏基本条件用于以及控制循坏的次数，若以i<n为循环条件，则意味着i终值为n-1,因为且i初值为1因而一共可以循坏n-1次。比要求少了1次，因而应改为i<=n或许i<n+1

{sum=sum*i;//若不为sum赋初值，则此处难以盘算sum*i

i++;

printf”sum=%d”,sum;//若printf语句有错误罕见考点有1个花样官方声明象征符号要与前面欲输出的变量的不同类型分歧此题%d与sum不同类型longint不分歧应改为%ld详见p69-78

sum应初始化 即加入sum=1

第四行改为：scanf%d,&n;

第六行改为：whilei<=n或许 whilei<n+1

第十行改为：printf”sum=%ld”,sum;

2．求一个数组中最大值及其下标。

main

{intmax,j,m;

inta[5];

forj=1;j<=5;j++//j=1为循环变量j赋初值为1同时用j作为数字元素的逻辑餐厅地址下标。因而输入的时分只能从a[1]开端输入，难以输入a[0].因而应将j赋初值0响应的循坏基本条件改为j<5或许j<=4用于以及控制循坏中执行5次

scanf%d,a;//若scanf语句有错误，罕见考点有两个：1花样官方声明象征符号要与前面欲赋值的变量的不同类型分歧，此题%d与a不同类型int分歧（详见p69-782变量的后面要有地址符号&

max=a[0];

forj=1;j<=5;j++//修正思绪与上一个for语句同

ifmax>a[j]

{max=a[j];

m=j;

printf下标：%dn最大值:%d,j,max//j为for语句的循坏变量，当for语句中执行完之后，j中的值为6并不最大值下标，中执行某一次循环的比拟进程中，将事先最大值的下标存在m里

第四行改为：forj=0;j<5;j++

第五行改为：scanf%d,&a[j];

第七行改为：forj=1;j<5;j++

第八行改为：ifmax<a[j]

第十三行改为：printf下标：%dn最大值:%d,m,max

3．用一个函数求两个数之和。

sumx,y//函数界说的普通方式p173-174

{floatz;

z=x+y;

return;//return语句前面也可以前往0常量、变量和表达式的值。

main

{floata,b;

intc;//若定义变量的语句有错误，罕见考点有两个：1变量的不同类型，2界说用于寄存运算后果的变量时，肯定要赋初值。普通赋值0或许循坏初值。

scanf”%f,%f”,&a,&b;

c=suma,b;

printf”nSumis%f”,sum;

第一行改为：floatsumfloatx,floaty;

第四行改为：returnz;或许returnz;

第八行：floatc;

第十一行：printf”nSumis%f”,c;

4．顺序读入20个整数，统计非负数个数，并盘算非负数之和.

#includstdio.h

main

inti,s,count,n=20;

inta[n];//数组定义的普通方式，详见p143,其中包括的常量直接表达式不能够为变量

s=count=1;

fori=1,i<20,i–//for语句的花样，三个直接表达式之间用分号，且分号不可省略

scanf%d,a[i];//若scanf语句有错误，罕见考点有两个：1花样官方声明象征符号要与前面欲赋值的变量的不同类型分歧，此题%d与n不同类型int分歧（详见p69-782变量的后面要有地址符号&

fori=0;i<20;i++

ifa[i]<0

break;//break与continue差别p128.改错题中若错误出现在break语句，则通常是将break换为continue反之，若错误出现在continue一般是将其换为break

+=a[i];

count++;

printfs=%fcount=%fn,s,count;//若printf语句有错误罕见考点有1个花样官方声明象征符号要与前面欲输出的变量的不同类型分歧

谜底：inta[20]

s=count=0;

fori=0;i<20;i–

scanf%d,&a[i];

continue;

printfs=%dcount=%dn,s,count;

5.从键盘输出整数x值,并输出y值.

main

{floatx,y;

scanf%d,&x;

y=3.5+x;

printfy=%d;

准确的:intx;floaty;

printfy=%f,y;

6编程盘算上面分段函数,输出x,输入y

main

{intx,y;

printfnInputx:n;

scanf%d,x;//错误的同上题scanf

ifx<0

y=x-1;

elsifx>=0||x<=10//||表现逻辑或，当右边直接表达式建立或许左边直接表达式成立时，整体直接表达式成立。&&表现逻辑与，当右边直接表达式和左边直接表达式同时建立时，整体直接表达式成立。此处用逻辑直接表达式来表示x区间[0,10],因而应改用逻辑与符号

y=2x-1;//C言语中乘号不能省略，且用*表现乘法运算

els

y=3x-1;//C言语中乘号不能省略，且用*表现乘法运算

printfy=%d,&i;//printf与scanf不必printf前面给出的变量名列表或直接表达式列表无需餐厅地址象征符号

第一处改为：scanf%d,&x;

第二处改为：x>=0&&x<=10

第三处改为：y=2*x-1;

第四处改为：y=3*x-1;

第五处改为：printfy=%d,y;

7.求100~300间能被3整除的数的和。

main

{intn;

longsum;//若定义变量的语句有错误，罕见考点有两个：1变量的不同类型，2界说用于寄存运算后果的变量时，肯定要赋初值,普通赋值0或许循坏初值。

forn=100,n<=300,n++//for语句的花样，三个直接表达式之间用分号，且分号不可省略

{

ifn%3=0//=赋值符号，用于将右边的值赋给左边的变量；==之间的关系象征符号，用来判别两个值是否相等改错中if前面直接表达式中的赋值符号是罕见的考点。

sum=sum*n;

printf%ld,sum;

第一处改为：longsum=0;

第二处改为：forn=100;n<=300;n++

第三处改为：ifn%3==0

第四处改为：sum=sum+n;

8.求表达式值

#includ<stdio.h>

#includ<math.h>

intfunintx,inty;

main

{inta,b;floatf;

scanf%d,%d,a,b;//与改错第1题中的scanf错误的相反

ifab>0{//C言语中乘号不能省略，且用*表现乘法运算

funa,b;//挪用带有前往值的函数，应将函数的前往值保存在变量里

printf”Theresultis:%dn”,&f//与第6题中printf错误的相反

elsprintferror!;}

funx,y//界说函数的普通方式p173-174

{floatresult;

result=sqrta+b;

return;//return语句前面也可以前往0常量、变量和表达式的值。

第一处改为：ifa*b>0

第二处改为：f=funa,b;

第三处改为：printf”Theresultis:%dn”,f;

第四处改为：floatfunintx,inty

第五处改为：f=funa,b;

第六处改为：result=sqrta*b;

第七处改为：returnresult;

• 编程题

1.输出2个整数，求两数的平方和并输出。

#includ<stdio.h>

intmainvoid

{intta,b,s;

printf”pleasinputa,b:n”;

scanf”%d%d,&a,&b;

s=a*a+b*b;

printf”theresultis%dn”,;

return0;

}

#includ<stdio.h>

#definPI3.14

intmainvoid

{doublr,area,girth;

printf”pleasinputr:n”;

scanf”%lf”,&r;

ifr>=0

{area=PI*r*r;

girth=2*PI*r;

printf”theareais%.2fn”,area;

printf”thegirthis%.2fn”,girth;}

els

printf”Inputerror!n”;

return0;

}

3已知函数y=fx编程完成输出一个x值，输入y值。