-
上机运行一个C程序必须经过编辑、编译、链接和执行4个步骤。
-
C语言本身没有输入输出语句，它的输入功能是由系统提供的输入函数实现的。
-
C语言源程序文件的后缀是 .c ;经过编译后,生成文件的后缀是 .obj ;经过连接后,生成文件的后缀是 .exe （经编译链接后生成的文件后缀是.exe）。
-
字符常量是一个用单引号括起来的单个字符（转义字符自带\开头,带两个或多个字符，但它只代表一个字符,\后跟八进制数据，比如'\101'表示字符A），在C语言中一个字符常量代表ASCII字符集中的一个字符，字符常量在内存。占4个字节，存放的是字符的ASCII码（整型数据） 。C语言规定所有字符常量都作为整型量来处理。此外，字符型数据与整型数据任意通用。
'\\'（√）表示字符斜杠常量\ "a"表示一个字符串（√）
与'a'区别？
C语言中"a"表示一个字符串，在内存中存储为 'a' '\0' 两个字符，大小为2字节。
C语言中'a'表示一个字符，在内存中存储为 'a' 一个字符，大小为1字节。
-
正确描述的C语言常量
（1）.25（√）
（2）5.（√）
（3）090（×）
原因：以0开头的表示他是一个八进制数，而它的各个位置最大小于8。
（4）'\xAA'=='\xaa' （√）
（5）'\02071' （×）
原因：编译后出现waring：multi-character character constant [-Wmultichar]。转义字符都有意义，而不是随意表示。所有的ASCII码都可以用“\”加数字（一般是8进制数字）来表示。
-
若有定义：int a=8,b=5,c执行语句c=a/b+0.4后，c的值为1
原因：c为整型变量，小数赋给c后被截断。
-
5.0%3是错误表达式。
原因：编译时报错c[Error] invalid operands to binary % (have 'double' and 'int')。C语言中"%"运算符的运算对象必须是整型。
-
数字字符0的ASCII值为48，若有以下程序： main() char a='1'，b='2'； printf("%c,"，b++)； printf("%d\n"，b- a)；
输出结果是2 2
原因：char型变量，表示的是字符，其内部存储的就是ascii码值，以整型方式输出时，打印的就是对应的ascii码值的10进制值。也就是%d输出ASCII码的值，而%c输出ASCII上对应的结果。
-
实型常量又称实数或浮点数。在C语言中可以用单精度型和双精度型两种形式表示实型常量，分别用类型名float和double进行定义 。
①在C语言中，则以“e”或“E”后跟一个整数来表示以“10”为底数的幂数。且C语言语法规定，字母e或E之前必须要有数字，且e或E后面的指数必须为整数。如e3、7e5.4、.e、e等都是非法的指数形式。注意：在字母e或E的前后以及数字之间不得插入空格。
②小数形式是由数字和小数点组成的一种实数表示形式。注意：小数形式表示的实型常量必须要有小数点。
0.1、.123、123.、0.0都是合法的。
-
逗号运算符是C语言运算符中优先级最低的运算符，比赋值运算符还低。其语法格式为：表达式1, 表达式2，表达式3。结合方式：自左至右，把最右侧表达式的值作为整个表达式的值。
例① a=5,b=3,a*b a=5,3的运算后的结果都是是5 3+2,10-6运算结果是4
例②p=q=2，q*6其中p=2，q=2，逗号表达式值为12。
p=(q=2,q*6)其中p=12，q=2，逗号表达式值为12。
若d为double型变量，则表达式d=1,d+5,d++的值是 1.0
解析：按照运算符优先级,从右往左,最后值为1。因为是double 所以要加小数部分
-
++(i+1)是非法赋值语句。（√）
原因：++a，这个a必须是变量而不能是表达式或者常量（这里的常量包括数值常量、符号常量、常变量）。由于(i+1)是表达式，虽然i是变量，仍然不符合C语言的语法规则，所以是错的。
-
合法整数 0Xbbc（√） afbc（×） 110110B（×）
-
若a是实型变量，C程序中允许赋值a=10，因此实型变量中允许存放整型数（×）
若a是实型变量，C程序中不允许赋值a=10，因此实型变量中只允许存放实型数（×）
原因：实型变量中只能存放实型变量a=10是将10做了隐式转换成实型变量后再存在a中的，只能说是整形和实型可以转换。
-
单目运算符--的运算对象可以使整型变量、实型变量、字符型变量，但不能是常量或表达式。
-
C源程序中不能表示的数制是二进制。
原因：虽然计算机只能识别二进制，但源程序不能用二进制表示。
-
C语言中的保留字（又称关键字）。指在高级语言中已经定义过的自，使用者不能再将这些字作为变量名或过程名使用。
main（×） scanf（×）
auto ：声明自动变量
double ：声明双精度变量或函数
int： 声明整型变量或函数
struct：声明结构体变量或函数
break：跳出当前循环
else ：条件语句否定分支（与 if 连用）
long ：声明长整型变量或函数
switch :用于开关语句
case：开关语句分支
enum ：声明枚举类型
register：声明寄存器变量
typedef：用以给数据类型取别名
char ：声明字符型变量或函数
extern：声明变量是在其他文件正声明
return ：子程序返回语句（可以带参数，也可不带参数）
union：声明共用数据类型
const ：声明只读变量
float：声明浮点型变量或函数
short ：声明短整型变量或函数
unsigned：声明无符号类型变量或函数
continue：结束当前循环，开始下一轮循环
for：一种循环语句
signed：声明有符号类型变量或函数
void ：声明函数无返回值或无参数，声明无类型指针
default：开关语句中的“其他”分支
goto：无条件跳转语句
sizeof：计算数据类型长度
volatile：说明变量在程序执行中可被隐含地改变
do ：循环语句的循环体
while ：循环语句的循环条件
static ：声明静态变量
if：条件语句
inline ：
restrict ：
_Alignas ：
_alignof ：
_Atomic：
_Bool：
_Complex：
_Generic：
_Imaginary：
_Noreturn：
_Static_assert：
_Therad_local：
-
c语言程序的基本结构是顺序结构，选择结构，循环结构。
它们的特点是：①只有一个入口；②只有一个出口；③结构内的每一部分都有机会被执行到（不代表每个部分都会被执行到）；④结构内不存在死循环。
-
C语言被称为“高级语言”是因为它们比较接近人们习惯使用的自然语言和数学语言。（√）
汇编语言被称为“低级语言”是因为程序不直观、繁琐、工作量大，且无通用性。（√）
高级语言跟低级语言的区分：低级语言是相对于高级语言而言，所谓低级，也是指接近电脑底层的编程语言。高级语言相对低级语言有较高的可读性，更易理解（但计算机不能直接识别和执行）。常见的低级语言包括：机器语言，嵌入式，汇编语言等；而高级语言则包括：c，java.net，Android，objectC，swift等。其中，低级语言的特点是执行效率高，速度快；因为它们都是接近底层编程，没有编译解析等过程，程序直接操控硬件，效率相对较高，但是其学习和编程调试难度较高，编程比较慢，且比较费时，项目周期长。而高级语言是依赖编译解析的，更接近于人类语言逻辑的编程语言，其可读性更高，开发效率更高，学习起来相对较容易；但是其执行效率较低级语言而言要低一些，而且高级语言的执行，需要依赖运行环境，在Java等编程语言中，如果环境配置不完善，或者环境版本不一致则可能导致程序无法执行。
高级语言：实现效率高，执行效率低，对硬件的可控性弱，目标代码大，可维护性好，可移植性好。
低级语言：实现效率低，执行效率高，对硬件的可控性强，目标代码小，可维护性差，可移植性差。
-
若有定义：int i=3,j;执行j=++i后，i，j的值都为4.但如果这里的j=i++则j为3.
例题 以下程序输出结果是________
main( ) {
int m=5;
if(m++>5)printf("%d\n"，m); else printf("%d\n"，m--); } if部分
-
在字符串中的//跟/*都不作为注释的开始，而是作为字符串的一部分。
-
C源程序中注释的标注是//（老是记反好无语）
-
语句括号中的使用条件
-
if可使用任意表达式
-
switch其值类型应为整数类型（包括字符型）
-
putchar可以使字符常量、整型常量、字符标量或整型变量（不能是字符串，只能输入一个字符）
23.以下程序的输出结果是a=%d,b=%d
# include <stdio.h>
main()
{ int a=2,c=5;
printf("a=%%d,b=%%d\n",a,c);
}
原因：在%%d中，"%%"代表输出一个"%"，d代表一个字符，所以输出结果是%d。
类似的
#include <stdio.h>
int main ()
{
int a =4;
printf("%%d\n",a);
printf("%%%d\n",a);
printf("%%%%d\n",a);
printf("%%%%%d\n",a);
printf("%%%%%%d\n",a);
printf("%%%%%%%d\n",a);
return 0;
} 输出结果分别为 %d %4 %%d %%4 %%%d %%%4
大致猜测是每两个"%%"都会被认为是输出一个"%"，也就是当%是偶数时输出的应该是带着%d（这里百分号不定，按具体情况确定）的结果，而带奇数时，剩下的一个%（前面每两个%%都被认为是输出一个%）跟d也就是平常输出十进制结果的格式%d。
-
if(x!=y) a=0 else a=1（语句错误，无;）
-
运算符优先级
-
int n=2; n+=n-=n-n执行完后n为4
-
设int a = 1, b=6 ;，执行表达式--a‖(b=8)后，a和b的值分别是0 6.理由同上
-
设整型变量m，n，a，b，c，d均为1，执行 ( m=a>b)&&(n=c>b) 后m，n的值是 0,1
原因：这跟&&运算顺序有关。当&&判断前面的部分不为真时，直接认定该表达式为假，而不执行后面的语句。这也能解释为什么n还是等于1，因为执行完前面已经判断为假，而不执行后面的语句。
-
一个实型变量的小数部分并不一定都是精确、有意义的（√）
所以当判断浮点数是否等于0时，不能直接用==0，而是得采取近似无限接近于0的方法（一个浮点变量的绝对值小于一个极小值，这个极小值就可以是1e-6至1e-7左右）。
-
设x,y分别为单精度和双精度类型变量.则 int(x+y)可将表达式x+y的运算结果强制转换为整型数据（×）
格式应为（类型名）（表达式）。在强制类型转换时，得到一个所需类型的中间数值，而原来便来那个的类型未发生改变。
-
输入输出格式
①指定数据宽度和小数位数，用%m.nf
-
.也算在宽度内。例如%4.3f 0.333 %5.2 0.33
-
scanf可以指定长度，但不能指定精度，也就是%md（d或其他格式）
-
当scanf输入时，整型变量输出的值大于m时，只能输出m的部分。当整型变量（其他类型的整数部分也是）printf输出时，当值大于m时会仍然把整数部分的值给全部输出。
阅读下面的程序
main()
{
int i,j;
scanf("%3d%2d",&i,&j);
printf("i=%d,j=%dn",i,j);
}
如果从键盘上输入1234567<回车>,则程序的运行结果是 i=123,j=45
-
阅读下面的程序
运行下面的程序时，从键盘输入字母H，则输出结果是 Hello! Good morning!Bye_Bye!
#include ＜stdio.h＞ main() char ch; ch=getchar()； switch(ch) case 'H':printf("Hello!\n"); case 'G':printf("Good moming!\n"); default:printf("Bye_Bye!\n");
switch语句的执行过程为：进入switch结构后，对条件表达式进行运算，然后从上至下寻找与条件表达式值相匹配的case，以此作为入口，执行switch结构中后面的各语句，直到遇到break语句，则跳出switch语句，如果各case都不匹配时，则执行default后面的语句。本题中ch为字符'H'，所以case'H'条件中的语句将被执行，由于没有break语句，所以case'G'后的语句也被执行，由于同样没有break语句，所以default后的语句也被执行了。
-
在文件包含命令#include中，文件名只能用尖括号括起来（×）
include文件两种表达形式：
①<> ② ""
30.易错
设有程序:
int n;
scanf("%d",&n);
if(n==1)
printf("1,");
if(n==2)
printf("2,");
else
printf("3,");
n分别等于1,2,3，输出结果是 B
A.1,2,3, B.1,3,2,3, C.1,2,3,3, D.1,2,1,3,
31.每个C程序文件中都必须有一个main()函数（×）
原因：每一个C程序中都必须有且只有一个main()函数，但一个C程序可以由多个程序文件组成，所以并非每个C程序文件中都必须要有一个main()函数。
32.在顺序结构中，各语句是按排列的先后次序顺序执行的，但也是有条件的，需要事先做出判断。（×）
33.字符串"\012945"是一个合法的字符串。（√）
原因：字符串中如果有\,则不再理解为转义符。
34.位运算符
右移 >>除 左移<<乘 无符号右移>>>
3<<2=12 也就是3*2*2=12 3>>1=1也就是3/2=1
35.逻辑表达式3<2||-1&&4>3-!0的值为:___1___。
-1,值非零，逻辑结果为1(真)；
36.以下不构成无限循环的语句或语句组是_A_。
A．n=0;do{++n;while(n＜=0);B．n=0;while(1)n++;C．n=10;while(n);n--;
注意：C选项有;
37.
①t为int类型,进入下面的循环之前,t的值为0
while(t=1)
{……}
,则以下叙述中,正确的是 循环控制表达式的值为1
原因：循环控制表达式为赋值表达式“t=1”，永远为1(为真)。
②（易错）已知int k=0;则语句while(k=1)k++;将一次也不执行.（×）
while中的表达式应为k==1，而本题却为k=1，是赋值表达式而不是逻辑表达式。因此，编译器将其值一直认为是1，因此表达式一直为真，陷入无限次的循环。
38.
下列程序的输出为_y=-1_。
main()
{int y=10;
while(y--);
printf("y=%d\n",y);
}
while循环先判断，再进行++或者--
(重要)下面程序的运行结果是x=1,y=20
#include<stdio.h>
int main()
{ int i,x,y;
i=x=y=0;
do
{ ++i;
if(i%2!=0)
{ x=x+i;i++;}
y=y+i++;
}while(i<=7);
printf("x=%d,y=%d\n",x,y);
}
39.
以下程序的运行结果是________。
main()
{
int i=1,sum=0;
while(i<10)sum=sum+1;i++;
printf("i=%d,sum=%d",i,sum);
}
看清楚while后面无花括号
40.
以下程序的执行结果是___1___。
void main()
{int x=0,s=0;
while(!x !=0)s+=++x;
printf("%d",s);}
41.
下面程序的运行结果是__D____。
#include<stdio.h>
void 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.2668 B.3981 C.4284 D.2870
42.
若有定义int c;则while(c=getchar());是正确的C语句.（√）
43.while,do-while和for语句中条件判断只能是关系表达式或逻辑表达式.（×）
可以为常量
break语句不能终止正在进行的用for语句实现的多层循环。（×）
在do-while循环中,任何情况下都不能省略while。（√）
do-while循环的while后的分号不可以省略。（√）
do{
statement(s);}while( condition );
44.
以下程序的运行结果是__21__ 。
#include <stdio.h>
main()
{
int a=3, b=7, t;
t=a > b ? a:b;
while(t % a || t % b)
t++;
printf("%d\n", t)
}
45.
下列程序的功能是输入一个整数，判断其是否是素数，若为素数输出1，否则输出0.请填空。
int main（）
{ int i, x, y=1;
scanf（"%d", &x）;
for（i=2; i<=x/2_; i++）
if(x%i==0){ y=0; break;}
printf（"%d＼n", y）;
}
46.
/*------------------------------------------------
【循环--程序设计】 Guo S.
2021-6-23
--------------------------------------------------
题目：编写函数double fun(int n)，为以下级数的前n项和，sum。
sum = 1 + 1/3 + 1/5 + 1/7 + 1/9 +...
提示：上述1为第一项，1/3为第二项，1/5为第三项，以此类推。
找到第n项的公式后，用循环语句实现。
不限循环语句，即（for、while或者do-while）均可。
--------------------------------------------------
注意：部分源程序给出如下。请勿改动主函数
main和其它函数中的任何内容，仅在函
数fun的花括号中填入所编写的若干语句。
*********Begin**********和********** End **********不可删除
------------------------------------------------*/
#include "stdio.h"
#include "math.h"
void bky_test();
//参数n为项数，
//当n小于等于0时，返回-1
//当n大于等于1时，返回sum值，
//sum由以下前n项给出
double fun(int n)
{
/**********Begin**********/
double sum=1;
int i;
if(n<=0)
return -1;
for(i=2; i<=n; i++)
{
sum += 1.0/(2*i-1);
}
return sum;
/********** End **********/
}
main()
{
double k;
int n;
printf("输入n：");
scanf("%d",&n);
k=fun(n);
printf("result=%lf\n",k);
bky_test();
}
void bky_test()
{
FILE *IN,*OUT;
int iIN, iIN2, i;
double iOUT;
IN=fopen("in.txt","r");
if(IN==NULL)
{
printf("in.txt ERROR!!!\nPlease Verify The Currernt Dir..It May Be Changed");
}
OUT=fopen("out.txt","w");
if(OUT==NULL)
{
printf("out.txt ERROR!!!\nPlease Verify The Current Dir.. It May Be Changed");
}
for(i=0;i<7;i++)
{
fscanf(IN,"%d",&iIN);
iOUT=fun(iIN);
fprintf(OUT,"%lf\n",iOUT);
}
fclose(IN);
fclose(OUT);
}
47. int n=10，a[n]；（×）
数组中规定个元素个数应为常量，const也不可以，只能是用define定义。
48.若有说明:int a[10];则对数组元素的正确引用是( ) 选项:a、a[10] b、a[3,5] c、a(5) d、a[10-10]
49.设已有申明char s[]="Good morning!";，不能将字符串内容正确显示到标准输出设备的语句是（ ）。
50.
fputs
int fputs(const char *str, FILE *stream);
返回值：该函数返回一个非负值，如果发生错误则返回 EOF(-1)。
str 代表要输出的字符串的首地址，可以是字符数组名或字符指针变量名。
stream 表示向何种流中输出，可以是标准输出流 stdout，也可以是文件流。
fgets
char *fgets(char *str, int n, FILE *stream);
例如：fgets(s,30,stdin);
fprintf
int fprintf ( FILE* stream, const char*format, [argument])
例如 fprintf(stdout,"%s",s);其中s为字符数组
fprintf() 的读写对象不是键盘和显示器，而是磁盘文件。
sprintf
int sprintf(char *string, char *format [,argument,...]);
将字符串b的内容转移到字符串a中 sprintf(a, "%s", b);
51.在C语言中，利用数组a存放字符串“Hello”，以下语句中正确的是（）。
A、char h[]="Hello!"; B、char h[]={'H','e','l','l','o','!'}; C、char h[10]; D.char h[6]="Hello!";
char s[ ]={'H','e','l','l','o'''!'} char s[ ]="Hello!" 长度一样吗？
不一样
char s[ ]={'H','e','l','l','o'''!'}是字符数组，长度为6
char s[ ]="Hello!" ，为字符串，相当于 char s[ ]={'H','e','l','l','o'','!',"\0"}，长度为7
在C语言中char str[]={'h','e','l','l','o'}不能将字符串"hello"正确赋给数组
只是赋值了字符串的内容，但是却没有赋值字符串的结束标志，所以，它不能将字符串"hello"正确赋给数组。但是可以通过以下形式可以赋值成功：char str[]={'h','e','l','l','o','\0'};或char str[6]={'h','e','l','l','o'}; 或char str[][6]={{'h','e','l','l','o','\0'}; 或char str[]="hello"; 数字不太一样 如：int a[3][4]={{1},{},{9}}; 或int a[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};但字符数组本身并不要求最后一个元素必须是'\0'注意区别。
52.有以下数组定义：int n[][3] ={{10,12,3},{40,5},{6,7}};则正确的值最小的下标表达式为n[1][2]。
正确的值好像也没什么特殊含义，被绕进去了……
53.设有以下字符数组s定义，则使表达式strlen(s)定义：遇到'\0'前的字符。所以char s[]={'\0','a','b','c','\0'};在定义中的长度为0.
54.如果定义字符数组存放很长的字符串"aaa…aaabbb…bbb"(…表示省略了若干a或b)，为了格式易读，需要在字符a和b之间分行排列，且不加入额外的空格，则应采用以下写法。
char s[] = "aaa…aaa\
bbb…bbb";
在结尾加\的方式，实现换行，编译时会忽略\及其后的换行符，当做一行处理。 具体
55.（易错）
看清楚前面没有类型说明符，A、B、C三选项只能在初始化时进行。正确答案为D.
56.有以下申明：int a[3][3] ={{10,12,3},{40,5},{6,7}},i;则以下能够按数组元素在内存中存放顺序依次显示其值的循环语句是for(i=0;i<9;i++) printf("%d\n",a[i/3][i%3]);
57.以下定义字符串数组的写法，正确的是（ ）。
A.char ss[][3]={{'a','b','c'},{'x','y'},{'z'}}; C.char ss[][3]={{'a','b'},{'x','y'},{'z','c'}};
58.以下定义字符串数组的写法，错误的是（ ）。
C.char ss[][3]={{'a','b','c'},{'x','y','z'}}; D.char ss[][4]={{'a','b','c','\0'},{'x','y','z','\0'}};
59.定义 int a[]={0,1,2,3}; 跟 int a[5]={0,1,2,3}; 是一样的。（错） 仔细看题目！！！
60.C语言为了增加执行的速度，并不会做数组的界限检查，所以范围检查的工作必须由程序设计师来做。（√）
61.运算符[]需要两个操作数，一个是数组名，一个是数组下标。（√）
62.字符数组 char a[]={'\0','a','b'}是长度为0的字符串。（√）
63.字符串不是C语言基本数据类型。（√） C语言六种基本数据类型short、int、long、char、float、double
64.一维字符数组就是字符串。（×）串是数组,但是字符数组不一定是字符串。这句话反着说是对的。
65.声明二维字符数组以存储字符串数组的语句char s[exp1][exp2];中，exp1即（限定）存储的字符串个数，exp2即（限定）每字符串最大长度。（×）
66.字符数组 char a[]={'\0','\0','\0'}不是一个字符串。（×）
67.已知char s[]={"Happy"}; 则sizeof(s)和strlen(s)的值分别为__6__和__5__。（请用半角阿拉伯数字作答） 已知char s[32]={"Happy"}; 则sizeof(s)和strlen(s)的值分别为__32__和___5__。（请用半角阿拉伯数字作答）
char *s="abcde"; 则sizeof(s)、sizeof(*s)、strlen(s)的值依次为 4 1 5
sizeof是求字节数大小，strlen是求字符串长度。sizeof(s)是求s的字节数大小，此时s是一个指针变量（int型），而在C++中一个指针变量固定占4个字节。sizeof(*s)是求*s的字节数大小，而*s是char类型，在C++中一个char变量占1个字节。strlen(s)是求s指向的字符串的长度，即为5。
68.若有如下整型数组a，则该数组的元素中,数值最大的元素的下标是_____。（请用半角阿拉伯数字作答）在百科园中只用写数字 如0
69.已知char str[10]={"Program"}; 系统会给数组str分配_10_个字节存储单元。（请用阿拉伯数字作答）
70.已知char str[ ]={"Program"}; 系统会给数组str分配__8_个字节存储单元。（请用阿拉伯数字作答）
71.如有以下二维字符数组申明： char ss[5][10];则用它存放多个字符串时，每个字符串长度不能超过 9个字符。
72.在程序中，使用下标表达式表示数组的元素。如果下标表达式中的下标值逾越了数组下标范围，不会引起编译错误，但会引起运行时\逻辑\计算错误。
73.在输出数组时，如果超出了数组索引值或常量值可容许的范围，编译程序虽不至发生错误，仍然会有数据输出，是何原因？原先内存内的残值
74.在C 语言中用于输入输出的字符串函数使用前应包含头文件 "stdio.h",使用其他字符串函数则应包含头文件 "string.h"。
75.设已有申明char s[100]，现要将中间带有空格的句子I love c programming.输入到s中保存，不能使用（ ）语句。
C.scanf("%[^\n]",s); D.scanf("%s",s);
^表示"非"，[^\n]表示读入换行字符就结束读入。正常用 scanf 函数输入的字符串不可以带空格，gets函数可以带。
76.如果数组里的元素想用键盘来输入，可以写成 int i, age[3]; for(i=0;i<=2;i++) scanf("%d", &age[i]);（√） 在C语言中，只有输入字符串时不用加&。
77.申明二维数组后，数组元素会自动初始化为缺省值。（×） 缺省值含义
78.字符串以'\0'字符为结束标志。元素中无该字符的字符数组不是字符串。（√）
79.数组被经常运用在递推与_排序\sorting_的问题上，可以有效率解决。
80.如有以下二维字符数组申明： char ss[5][10];则用它存放多个字符串时，每个字符串长度不能超过 9个字符。
81.
/*字符串到整数
------------------------------------------------
【程序设计】 guo s.
2021-01-25
--------------------------------------------------
完成函数 int str2int_0(char x[])，
参数x为纯数字字符构成的字符串，转为正整数并返回。
如果x中有非数字字符，包括'+', '-', '.'等，则返回-1
比如：
字符串x >>> 返回值
----------------------------
"12345" >>> 12345
"987" >>> 987
"70" >>> 70
"07" >>> 7
"007" >>> 7
"+12" >>> -1
"-12" >>> -1
"12.23" >>> -1
".369" >>> -1
"12.369" >>> -1
----------------------------
--------------------------------------------------
注意：部分源程序给出如下。请勿改动主函数
main和其它函数中的任何内容，仅在函
数的花括号中填入所编写的若干语句。
*********Begin**********和********** End **********不可删除
------------------------------------------------*/
#include<stdio.h>
void bky();
int str2int_0(char x[])
{
/**********Begin**********/
int xx, i, len;
i=0; xx=0;
for(i=0; x[i]!='\0'; i++)
{
if(x[i]<'0'||x[i]>'9')
{
xx = -1;
break;
}
xx *= 10;
xx += x[i]-'0';
}
return xx;
/********** End **********/
}
main()
{
int n, i, num;
char s[32];
printf("请输入测试次数:");
scanf("%d",&n);
for(i=0;i<n;i++)
{
printf("请输入第%d个字符串:",i+1);
scanf("%s", s);
num = str2int_0(s);
printf("结果:%d\n",num);
}
bky();
}
void bky()
{
FILE *IN,*OUT;
int n, x, i;
char s[32];
int o;
IN=fopen("in.dat","r");
if(IN==NULL)
{
printf("Read FILE Error");
}
OUT=fopen("out.dat","w");
if(OUT==NULL)
{
printf("Write FILE Error");
}
fscanf(IN,"%d",&n);
for(i=0;i<n;i++)
{
fscanf(IN,"%s", s);
o = str2int_0(s);
fprintf(OUT,"%d\n",o);
}
fclose(IN);
fclose(OUT);
return;
}82.同上
/*字符串到整数
------------------------------------------------
【程序设计】 guo s.
2021-01-25
--------------------------------------------------
完成函数 int str2int_2(char x[], int *res);
参数x为首位可能是'-'，'+'，后续为纯数字字符构成的字符串，
转为整数值到*res，并返回0。
如果x中有除首位有'+'和'-'外，其他有非数字字符时，则返回-1
比如：
字符串x >>> *res 返回值（整数）
--------------------------------------
"12345" >>> 12345 0
"-987" >>> -987 0
"+70" >>> 70 0
"07" >>> 7 0
"007" >>> 7 0
"12.23" >>> 可无视 -1
"12+" >>> 可无视 -1
".369" >>> 可无视 -1
"12.369" >>> 可无视 -1
"-1-2" >>> 可无视 -1
"+1+2" >>> 可无视 -1
--------------------------------------
--------------------------------------------------
注意：部分源程序给出如下。请勿改动主函数
main和其它函数中的任何内容，仅在函
数的花括号中填入所编写的若干语句。
*********Begin**********和********** End **********不可删除
------------------------------------------------*/
#include<stdio.h>
void bky();
int str2int_2(char x[] , int *res)
{
/**********Begin**********/
int xx=0, i, len, flg=1;
i=0; *res=0;
if(x[0]=='+') {
flg=1; i=1;
}
if(x[0]=='-')
{
flg=-1; i=1;
}
for(; x[i]!='\0'; i++)
{
if(x[i]<'0'||x[i]>'9')
{
xx = -1;
break;
}
*res *= 10;
*res += x[i]-'0';
}
if(xx!=-1)
*res *= flg;
return xx;
/********** End **********/
}
main()
{
int n, i, num, res;
char s[32];
printf("请输入测试次数:");
scanf("%d",&n);
for(i=0;i<n;i++)
{
printf("请输入第%d个字符串:",i+1);
scanf("%s", s);
num = str2int_2(s, &res);
printf("返回:%d\n",num);
if(num==0)
printf("*res:%d\n", res);
}
bky();
}
void bky()
{
FILE *IN,*OUT;
int n, x, i;
char s[32];
int o, res;
IN=fopen("in.dat","r");
if(IN==NULL)
{
printf("Read FILE Error");
}
OUT=fopen("out.dat","w");
if(OUT==NULL)
{
printf("Write FILE Error");
}
fscanf(IN,"%d",&n);
for(i=0;i<n;i++)
{
fscanf(IN,"%s", s);
o = str2int_2(s, &res);
fprintf(OUT,"%d\n",o);
if(o==0)
fprintf(OUT,"%d\n", res);
}
fclose(IN);
fclose(OUT);
return;
}83.
/*字符串到浮点数
------------------------------------------------
【程序设计】 guo s.
2021-01-25
--------------------------------------------------
完完成函数int str2double_1(char [], double *re)，
参数x是可能含'.'的数字字符串，转为双精度浮点数，赋值*re，并返回0。
如果含多个小数点'.'，或其他非数字字符的字符，返回-1。
比如：
字符串x >>> 对应*re值 返回值
-------------------------------------
"12.345" >>> 12.345000 0
"12.369872" >>> 12.369872 0
"12" >>> 12.000000 0
".369" >>> 0.369000 0
"2.369" >>> 2.369000 0
"12.23.45" >>> 可以无视 -1
"12.23+45" >>> 可以无视 -1
"+.369" >>> 可以无视 -1
"-1.369" >>> 可以无视 -1
-------------------------------------
注意：部分源程序给出如下。请勿改动主函数
main和其它函数中的任何内容，仅在函
数的花括号中填入所编写的若干语句。
*********Begin**********和********** End **********不可删除
------------------------------------------------*/
#include <stdio.h>
#include <math.h>
void bky();
int str2double_1(char x[] , double *res)
{
/**********Begin**********/
double xx, y;
int i, len;
i=0; xx=0;
while(x[i] !='.' && x[i]!='\0')
{
if(x[i]<'0'||x[i]>'9') return -1.000000;
xx *= 10;
xx += x[i]-'0';
i++;
}
if(x[i] =='.')
{
len = 0;
y = 0;
i++;
while(x[i]!='\0')
{
if(x[i]<'0'||x[i]>'9') return -1.000000;
y *= 10;
y += (x[i]-'0');
i++;
len++;
}
}
xx += y/pow(10, len);
*res = xx;
return 0;
/********** End **********/
}
main()
{
int n, i, num;
double res;
char s[32];
printf("请输入测试次数:");
scanf("%d",&n);
for(i=0;i<n;i++)
{
printf("请输入第%d个字符串:",i+1);
scanf("%s", s);
num = str2double_1(s, &res);
printf("返回:%d\n", num);
if(num!=-1)
printf("res=%lf\n", res);
}
bky();
}
void bky()
{
FILE *IN,*OUT;
int n, x, i;
char s[32];
int o;
double res;
IN=fopen("in.dat","r");
if(IN==NULL)
{
printf("Read FILE Error");
}
OUT=fopen("out.dat","w");
if(OUT==NULL)
{
printf("Write FILE Error");
}
fscanf(IN,"%d",&n);
for(i=0;i<n;i++)
{
fscanf(IN,"%s", s);
o = str2double_1(s, &res);
fprintf(OUT,"%d\n", o);
if(o!=-1)
fprintf(OUT,"%lf\n", res);
}
fclose(IN);
fclose(OUT);
return;
}84.
/*字符串到浮点数
------------------------------------------------
【程序设计】 guo s.
2021-01-25
--------------------------------------------------
完成函数 int str2double_2(char [], double *re)，
参数x是可能含'.'和第一个为'+'或'-'的数字字符串，
转为双精度浮点数，赋值*re，并返回0。
如果含多个小数点'.'，或其他非数字字符的字符，
包括非首位的'+', '-'等，返回-1。
比如：
字符串x >>> 对应*re值 返回值
----------------------------
"+12.345" >>> 12.345000 0
"12.369872" >>> 12.369872 0
"12" >>> 12.000000 0
".369" >>> 0.369000 0
"-12.369" >>> -12.369000 0
"-.369" >>> -0.369000 0
"-0.369" >>> -0.369000 0
"12.23+45" >>> 可以无视 -1
"12.23.45" >>> 可以无视 -1
"12-23.45" >>> 可以无视 -1
-------------------------------------
注意：部分源程序给出如下。请勿改动主函数
main和其它函数中的任何内容，仅在函
数的花括号中填入所编写的若干语句。
*********Begin**********和********** End **********不可删除
------------------------------------------------*/
#include <stdio.h>
#include <math.h>
void bky();
int str2double_2(char x[] , double *res)
{
/**********Begin**********/
double xx, y;
int i, len, flg=1;
i=0; xx=0;
if(x[0]=='-'){
flg=-1;
i++;
}
if(x[0]=='+') i++;
while(x[i] !='.' && x[i]!='\0')
{
if(x[i]<'0'||x[i]>'9') return -1.000000;
xx *= 10;
xx += x[i]-'0';
i++;
}
if(x[i] =='.')
{
len = 0;
y = 0;
i++;
while(x[i]!='\0')
{
if(x[i]<'0'||x[i]>'9') return -1.000000;
y *= 10;
y += (x[i]-'0');
i++;
len++;
}
}
*res = xx + y/pow(10, len);
return 0;
/********** End **********/
}
main()
{
int n, i, num;
double res;
char s[32];
printf("请输入测试次数:");
scanf("%d",&n);
for(i=0;i<n;i++)
{
printf("请输入第%d个字符串:",i+1);
scanf("%s", s);
num = str2double_2(s, &res);
printf("返回:%d\n", num);
if(num!=-1)
printf("res=%lf\n", res);
}
bky();
}
void bky()
{
FILE *IN,*OUT;
int n, x, i;
char s[32];
int o;
double res;
IN=fopen("in.dat","r");
if(IN==NULL)
{
printf("Read FILE Error");
}
OUT=fopen("out.dat","w");
if(OUT==NULL)
{
printf("Write FILE Error");
}
fscanf(IN,"%d",&n);
for(i=0;i<n;i++)
{
fscanf(IN,"%s", s);
o = str2double_2(s, &res);
fprintf(OUT,"%d\n", o);
if(o!=-1)
fprintf(OUT,"%lf\n", res);
}
fclose(IN);
fclose(OUT);
return;
}86.有以下函数定义： void fun(int n, double x) {…} 若以下选项中的变量都已经正确定义并赋值，则对函数fun的正确调用语句是______。 A．fun(int y, double m) ;B．k=fun(10, 12.5);C．fun(x,n);D．void fun(n, x);
若函数fun没有返回值，选项B错误；选项A中应将y和m前面的函数的类型说明符去掉，故选项A不正确；；选项D在调用函数时，不应该再声明其返回类型，故迭项D不正确．
87.（易错）
请读程序:
#include<stdio.h>
func( int a, int b)
{
int c;
c=a+b;
return c;
}
main()
{
int x=6, y=7, r;
r=func( func(x--,y--),x+y);
printf("%d\n",r);
}
上面程序的输出结果是___26_。 传递过后，在函数中自减。
88.如果要限制一个变量只能为本文件所使用，必须通过_静态外部变量_来实现。
89.函数形参的值也可以传回对应的实参（×）
函数参数传递是个不可逆的过程，实参将其值传递给形参，调用结束时形参并不将其值回传给实参
90.
下面程序的输出是_3600__。
int w=3;
main()
{
int w=10;
printf("%d\n",fun(5)*w);
}
fun(int k)
{
if(k==0) return w;
return(fun(k-1)*k);
}
91.构成C程序的基本单位是函数（√）
92.
以下程序的输出的结果是__2 6__。 静态局部变量是在编译时赋初值的，以后每次调用时不再重新赋值，而是保留上次函数调用结束时的值。
int x=3;
main()
{
int i;
for (i=1;i<x;i++) incre();
}
incre()
{
static int x=1;
x*=x+1;
printf(" %d",x);
}
93.
以下函数值的类型是__int__。
fun(float x)
{ float y;
y=3*x-4;
return y;
}
94.以下只有在使用时才为该类型变量分配内存的存储类说明是auto和 register。
95.
对以下程序，正确的说法是（程序中没有错误，可以正常运行 ）
sub (char x,char y)
{
int z;
z=x%y;
return z;
}
main( )
{
int g=5,h=3,k;
k=sub(g,h);
printf("%d\n",k);
}
96.
对以下程序，正确的说法是（ ）
long fib(int n)
{
if(n>2) return(fib(n-1)+fib(n-2));
else return (2);
}
main()
{
printf("%d\n",fib(3));
}
fib(3) =fib(2)+fib(1)，而fib(2)的返回值为2，fib(1)的返回值也为2，故输出的fib(3)的值为4。
97.
下面程序的输出是（6）
fun3(int x)
{
static int a=3;
a+=x;
return(a);
}
main()
{
int k=2,m=1,n;
n=fun3(k);
n=fun3(m);
printf("%d\n",n);
}
98.有一函数的定义如：void fun(char *s){……}，则不正确的函数调用是( )
[单选题]
A.main() {char a[20]=”abcdefgh”; fun(a); …… }
B.main() { char a[20]=”abcdefgh”; fun(&a[0]); …… }
C.main() { char a[20]=”abcdefgh”; char *p=a;fun(p); …… }
D.main() { char a[20]=”abcdefgh”; fun(a[]); …… }
99.
设在主函数中有以下定义和函数调用语句,且fun函数为void类型;正确 的fun函数的首部应为（ void fun(double b[][22])）（要求形参名为b）
main()
{
double s[10][22];
int n;
fun(s);
}
100.在函数调用过程中，如果函数funA调用了函数 funB，函数funB又调用了函数funA,则称为函数的直接递归调用。（×） 递归调用就是一种特殊的嵌套调用，是某个函数调用自己，或者是调用其他函数后再次调用自己。如果一个函数在其内部调用自己，我们称这样的调用为直接调用；若两个函数之间相互调用，则成为间接调用。题目中funA和funB函数之间互相调用，因此称为间接递归调用。
101.在c语言中，static类型的变量在函数内说明，而在整个程序运行期间都存在，因此c语言中全局变量的存储类别是static.（×） static可应用于应用于内部变量、外部变量和函数
102.c语言规定形参可以是常量、变量或表达式，只要与其对应的实参类型一致即可（×） 形参只能是变量
103.在main函数中定义的变量称为全局变量（×） 函数体内定义的变量都是局部变量
104.函数调用时的实参和形参之间的数据是单向的__值__传递.
105.
/*------------------------------------------------
【程序设计】
--------------------------------------------------
题目:要求：求100以内的所完数。所谓完数，是指该数的因子之和（不包含本身）等于该数本身的数，例如：
6=1+2+3
具体要求如下：
（1）函数
int process(int n); 判断一个数是不是完数，如果是，返回1，否则返回0；
（2）主函数
调用函数找出100以内所有的完数并输出。
注意：部分源程序给出如下。请勿改动主函数
main和其它函数中的任何内容，仅在函
数的花括号中begin和end之间填入所编写的若干语句。
*********Begin**********和********** End **********不可删除
------------------------------------------------*/
#include<stdio.h>
int process(int n)
{
/********** Begin **********/
int s=0,i;
for(i=1;i<n;i++)
{
if(n%i==0) s=s+i;
}
if(s==n) return 1;
else return 0;
/********** End **********/
}
int main()
{
int i;
FILE *outf; /*系统判分使用*/
for(i=1;i<=100;i++)
{
if(process(i)==1)
printf("%d\n",i);
}
printf("\n");
/*此处将结果输出到文件"bc01.in"，请勿改动，否则影响判分*/
outf=fopen("bc01.in","w");
for(i=1;i<=100;i++)
{
if(process(i)==1)
fprintf(outf,"%d\n",i);
}
fprintf(outf,"\n");
fclose(outf);
return 0;
}106.
/*------------------------------------------------
【程序设计】
--------------------------------------------------
题目:编程实现：s=a+aa+aaa+...+aaa...aaa的值，其中a是1~9之间的某个数字，n是一个正整数。
例如：若a=2,n=5,则s=2+22+222+2222+22222=24690
具体要求如下：
（1）long int process(int a,int n):计算a+aa+aaa+aa...a的值，并返回结果；
（2）主函数中调用该函数计算后输出结果。
注意：部分源程序给出如下。请勿改动主函数main
和其它函数中的任何内容，仅在函数fun的花
括号中填入所编写的若干语句。
*********Begin**********和********** End **********不可删除
--------------------------------------------------*/
#include<stdio.h>
void bky();
long int process(int a,int n)
{
/********** Begin **********/
int i;
long int s=0,t=0;
for(i=0;i<n;i++)
{
t=t*10+a;
s=s+t;
}
return s;
/********** End **********/
}
int main()
{
long s=0;
int a,n;
printf("请输入a的值(1-9):");
scanf("%d",&a);
printf("请输入正整数n的值:");
scanf("%d",&n);
s=process(a,n);
printf("结果为:%ld\n",s);
bky();
}
void bky()
{
FILE *IN,*OUT;
int a,n;
long o;
int c;
IN=fopen("in.dat","r");
if(IN==NULL)
{
printf("Read FILE Error");
}
OUT=fopen("out.dat","w");
if(OUT==NULL)
{
printf("Write FILE Error");
}
for(c=1;c<=5;c++)
{
fscanf(IN,"%d%d",&a,&n);
o=process(a,n);
fprintf(OUT,"%ld\n",o);
}
fclose(IN);
fclose(OUT);
}
/*------------------------------------------------
【程序设计】
--------------------------------------------------
题目：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问第n个月的兔子总数为多少？输入例子如下：
1: 1
3: 2
7: 13
11: 89
20: 6765
--------------------------------------------------
注意：部分源程序给出如下。请勿改动主函数
main和其它函数中的任何内容，仅在函
数的花括号中begin和end之间填入所编写的若干语句。
*********Begin**********和********** End **********不可删除
------------------------------------------------*/
#include <stdio.h>
#include <math.h>
void bky();
int countRabbit(int n)
{
/**********Begin**********/
if(n==1||n==2)
return 1;
else
return countRabbit(n-1)+countRabbit(n-2);
/********** End **********/
}
int main()
{
int n;
int result;
printf("input a Number: ");
scanf("%d",&n);
result = countRabbit(n);
printf("%d\n",result);
bky();
return 0;
}
void bky()
{
FILE *IN,*OUT;
int i;
int n;
int result;
IN=fopen("in.dat","r");
if(IN==NULL)
{
printf("Please Verify The Currernt Dir..it May Be Changed");
return;
}
OUT=fopen("out.dat","w");
if(OUT==NULL)
{
printf("Please Verify The Current Dir.. it May Be Changed");
return;
}
for(i=0;i<5;i++)
{
fscanf(IN,"%d",&n);
result = countRabbit(n);
fprintf(OUT,"%d\n",result);
}
fclose(IN);
fclose(OUT);
}108.
若有以下程序
#include <stdio.h>
int f(int a)
{ return a%2; }
main()
{ int s[8]={1,3,5,2,4,6},i,d=0;
for (i=0;f(s[i]);i++) d+=s[i];
printf("%d\n",d);
}
程序输出的结果为__9_。
109.若调用一个函数，且此函数中没有return语句，该函数返回一个不确定的值。
110.
下面程序的输出结果是_20 10_。
#include <stdio.h>
main( )
{
int x=10；
{
int x=20；
printf ("%d，", x)；
}
printf("%d\n", x)；
} 以大括号为分界，将程序分为体内和体外执行，互不干扰。（如变量定义等）
111.在main函数中定义的变量称为全局变量（×） 在函数外定义的也是
112.在C语言中，形参的缺省存储类是auto
113.设有计算平均的函数fun，声明如下：double fun(double x[], int num); 第一个参数是存放数据的首地址，第二个参数是计算平均时的从x开始的元素个数；并设已有double y[1024]; 都已经赋值。调用计算后512个数的平均，即y[512]开始到y[1023]的平均ave2=fun( y+512或&y[512], _512__);
114.设有统计字符串中英文字符个数的函数fun，声明如下：int fun(char x[]); 第一个参数是要统计的字符串的首地址，函数返回统计到的个数，并设已有char a[64]; 其中字符串a的元素都已经赋值。通过fun得到字符串a中的英文字符个数num的调用方法是 num=fun(a)或num=fun(&a[0])_ ; 【注意：不要加空格，不要加分号】
115.设有字符串排序函数fun，声明如下：void fun(int num, char [][32]); 第一个参数是参与排序的字符串个数，第二个参数是参与排序的字符串，每个字符串32个字符；并设已有12个字符串char name[12][32]; 都已经赋值。将12个字符串排序的调用方法是 12 name或&name[0][0]或name[0]
7413
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
