C语言试题三（程序选择题进阶_含知识点详解）

函数

1.
#include <stdio.h>
int Sub(int a, int b)
{
    return (a- b);}
main()
{
    int  x, y, result = 0;	
scanf("%d,%d", &x,&y ); 
result = Sub(x,y ) ; 
printf("result = %d\n",result);
}
当从键盘输入:6,3运行结果为：
result =3  

2. 
#include <stdio.h>
int  min( int x, int y )  
{
     int  m；
 if  ( x> y )  m = x；
else 	    m = y；
 return(m)；    
｝
 main()   {
     
 int  a=3,b=5,abmin ；              		 		 
abmin = min(a,b)；          		 
printf(“min  is  %d”， abmin)； 
}
运行结果为：
min  is  5

3.
#include<stdio.h>
 func(int x) {
      
    x=10;
    printf(“%d, ”,x);
 }
 main( )
 {
      int x=20;
    func(x);
    printf(“%d”, x);
 }
运行结果为：
10, 20



4.
#include <stdio.h>
int m=4;
int func(int x,int y)
{
      int m=1;
return(x*y-m);
}
main()
{
    int a=2,b=3;
printf("%d\n",m);
printf("%d\n",func(a,b)/m); 
}
运行结果为：
4
1

整型变量m在函数外定义，因此m为全局变量，其作用于范围为其定义位置开始，一直到整个程序结束。因此func与main函数都可以访问m

程序首先执行main函数
执行printf("%d\n",m); 即输出m中的值4，并换行。
执行printf("%d\n",func(a,b)/m);即输出表达式func(a,b)/m的值，为了计算该表达式，
需要调用函数func。此时main将a,b中的2和3值作为实参传递给func的x和y
程序开始转向执行func函数，此时func中的x为2，y为3
	执行int m=1; 此句定义了一个局部变量m并赋值为1 。m的作用域为其所在的复合
语句，即func的函数体，因此在func的函数体重，有限访问局部变量m。
执行return(x*y-m);  即return（2*3-1） ;返回的是整数5.
func函数返回至main函数中的被调用处
main函数中func(a,b)的值为5，func(a,b)/m=5/4=1,注意，在main函数中访问的m为全局变量m，此时main函数无法访问func中的m，因为不在func中m的作用域。


5.
#include <stdio.h>
int fun(int a, int b)
{
     if(a>b)   return(a);
else    return(b);
}
main()
{
     int x=15, y=8, r;
r= fun(x,y);
printf("r=%d\n", r);
}
运行结果为：r=15
程序首先执行main函数
执行r= fun(x,y);即将func(x,y)的值赋给r，为了计算该表达式，需要调用函数func。此时main将x,y中的15和8值作为实参传递给func的a和b
程序开始转向执行func函数，此时func中的a为15，b为8
	执行if语句;判断if后面的表达式，a>b成立，因此执行相应的操作return(a)；即返回
	a的值 。
func函数返回至main函数中的被调用处
main函数中func(x,y)的值为15，即将15赋给r。
执行printf("r=%d\n", r); 即输出r=15

6.
#include <stdio.h>
int fac(int n)
{
     int f=1,i;
for(i=1;i<=n;i++)
  f=f * i;
return(f);
}
main()
{
     int j,s;
scanf(“%d”,&j);
s=fac(j);
printf("%d!=%d\n",j,s);
}
如果从键盘输入3，  运行结果为： 3!=6

程序首先执行main函数
执行r= fun(x,y);即将func(x,y)的值赋给r，为了计算该表达式，需要调用函数func。此时main将x,y中的15和8值作为实参传递给func的a和b
程序开始转向执行func函数，此时func中的a为15，b为8
	执行if语句;判断if后面的表达式，a>b成立，因此执行相应的操作return(a)；即返回
	a的值 。
func函数返回至main函数中的被调用处
main函数中func(x,y)的值为15，即将15赋给r。
执行printf("r=%d\n", r); 即输出r=15

7. 
#include <stdio.h>
unsigned fun6(unsigned num)
 {
     unsigned k=1;
do 
{
     k*=num%10; 
num/=10;
}while(num);
     return k;
}
main()
 {
     unsigned n=26;
  printf(“%d\n”,fun6(n));
 }
运行结果为：12

程序首先执行main函数
执行printf(“%d\n”,fun6(n)); 即输出表达式func(6)的值，为了计算该表达式，需要调用
函数func。此时main将n中的26作为实参传递给func的num
程序开始转向执行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，表示循环条件不成立，
			结束循环
	执行return k; 即返回至main函数中的被调用处
执行main函数
继续执行printf(“%d\n”,fun6(n)); 即输出12

8.
#include <stdio.h>
int max(int x, int y);
main()
{
     int a,b,c;
a=7;b=8;
c=max(a,b);
printf("Max is %d",c);
}
max(int x, int y)
{
     int z;
z=x>y? x : y;
return(z) ;
}
运行结果为：
Max is 8

指针

1.
# include < stdio .h >
main (  )
{
     int  x[ ] = {
    10, 20, 30, 40, 50 };
int  *p ;
p=x;
printf ( “%d”, *(p+2 ) ); 
}                 
运行结果为： 
30
首先定义一个整型数组x，x的长度为5;然后定义一个指针变量p;对p进行初始化，将数组x的地址赋给p。因此此时p中存放的数组x的首地址，即数组中第一个元素x[0]的地址。
然后执行printf语句，输出表达式*(p+2)的值。p+2表示以p当前指向的位置起始，之后第2个元素的地址，即a[2]的地址。*(p+2)则表示该地址内所存放的内容，即a[2]的值30,因此输出30

2.
#include <stdio.h>
main( )
{
      char s[]=”abcdefg”;
  char *p;
  p=s;
  printf(“ch=%c\n”,*(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


3.
#include<stdio.h>
main ( )
{
     int a[]={
    1, 2, 3, 4, 5} ；
int x, y, *p；
p=a；
x=*(p+2)；
printf("%d：%d \n", *p, x)；
}
运行结果为: 
1:3
首先定义一个整型数组a，并对a进行初始化; 然后定义整型变量x,y，整型指针变量p; 再将数组a的地址赋给p。因此此时p中存放的数组a的首地址，即数组中第一个元素a[0]的地址。执行x=*(p+2)；p+2表示以p当前所指向的位置起始，之后第2个元素的地址，即a[2]的地址。*(p+2)则表示该地址内所存放的内容，即a[2]的值3，然后再把3赋给x
然后执行printf语句，先输出表达式*p的值。此时*p表示的是p所指向变量的内容，即a[0]的值1。再输出一个冒号。然后再输出x中的值3。

4.
#include<stdio.h>
main()
{
      int  arr[ ]={
    30,25,20,15,10,5},  *p=arr;
p++;
 printf(“%d\n”,*(p+3));
}
运行结果为：10

首先定义一个整型数组arr，并对arr进行初始化; 然后定义整型指针变量p; 再将数组arr的地址赋给p。因此此时p中存放的数组arr的首地址，即数组中第一个元素a[0]的地址。
执行p++，即p=p+1。p+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

5.
#include <stdio.h>
main( )
{
      int  a[ ]={
    1, 2, 3, 4, 5, 6};
   int  x, y, *p;
   p = &a[0];
   x = *(p+2);
   y = *(p+4);
   printf(“*p=%d, x=%d, y=%d\n”, *p, x, y);
}
  运行结果为： 
 *p=1, x=3, y=5
首先定义一个整型数组a，并对a进行初始化; 然后定义整型变量x,y，整型指针变量p; 再将数组元素a[0]的地址赋给p。
执行x=*(p+2)；p+2表示以p当前所指向的位置起始，之后第2个元素的地址，即a[2]的地址。*(p+2)则表示该地址内所存放的内容，即a[2]的值3，然后再把3赋给x
执行y = *(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。


6.
#include<stdio.h>
 main( )
  {
     static char a[ ]=”Program”, *ptr;
    for(ptr=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+2。ptr+2表示以ptr当前所指向的位
置起始，之后第2个元素的地址,即a[2]的地址，然后将a[2]的地址赋给ptr。a[2]的地
址等价于a+2，因此循环条件ptr<a+7成立，继续执行循环体
第2次执行循环体
	执行putchar(*ptr); 即输出*ptr所对应的字符。此时ptr指向数组中的第3个元素，即
	a[2],因此*ptr表示a[2]中的值，即’o’.
	执行完循环体，转向执行表达式3，即ptr= ptr+2。ptr+2表示以ptr当前所指向的位
置起始，之后第2个元素的地址,即a[4]的地址，然后将a[4]的地址赋给ptr。a[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+2。ptr+2表示以ptr当前所指向的位
置起始，之后第2个元素的地址,即a[6]的地址，然后将a[6]的地址赋给ptr。a[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+2。ptr+2表示以ptr当前所指向的位
置起始，之后第2个元素的地址,即a[8]的地址，然后将a[8]的地址赋给ptr。a[6]的地址等价于a+8，因此循环条件ptr<a+7即a+8<a+7不成立，结束循环。

7.
#include <stdio.h>
char s[]=”ABCD”;
main()
 {
     char *p;
   for(p=s;p<s+4;p++) 
printf(“%c %s\n”,*p,p);
 }
运行结果为： 
A  ABCD
B  BCD
C  CD
D  D

首先定义一个字符型数组s，并对s进行初始化; 数组s是全局变量，其有效范围从其定义开始至整个程序结束。

执行main函数
	定义一个字符型指针p。
执行for语句  p=s为表达式1，将数字s的首地址赋给p；表达式2（循环条件）p<s+4；表达式3为p++，即p= p+1；
第1次执行循环体
			执行printf(“%c %s\n”,*p,p);即以字符%c形式输出*p所对应的字符。此时p指
向数组中的第1个元素，即s[0],因此*p表示a[0]中的值，即’A’. 然后再以字
符串%s的形式输出以p中地址为首地址的整个字符串，即输出ABCD
			执行完循环体，转向执行表达式3，即p= p+1。p+1表示以p当前所指向的
位置起始，之后1个元素的地址,即s[1]的地址，然后将a[1]的地址赋给p。
s[1]的地址等价于s+1，因此循环条件p<s+4成立，继续执行循环体
第2次执行循环体
			执行printf(“%c %s\n”,*p,p);即以字符%c形式输出*p所对应的字符。此时p指
向数组中的第2个元素，即s[1],因此*p表示s[1]中的值，即’B’. 然后再以字
符串%s的形式输出以p中地址为首地址的整个字符串，此时p指向s[1]，即
从s[1]开始，依次输出后面的字符串，因此又输出BCD
			执行完循环体，转向执行表达式3，即p= p+1。p+1表示以p当前所指向的
位置起始，之后1个元素的地址,即s[2]的地址，然后将a[2]的地址赋给p。
s[2]的地址等价于s+2，因此循环条件p<s+4成立，继续执行循环体
第3次执行循环体
			执行printf(“%c %s\n”,*p,p);即以字符%c形式输出*p所对应的字符。此时p指
向数组中的第3个元素，即s[2],因此*p表示s[2]中的值，即’C’. 然后再以字
符串%s的形式输出以p中地址为首地址的整个字符串，此时p指向s[2]，即
从s[2]开始，依次输出后面的字符串，因此又输出CD
			执行完循环体，转向执行表达式3，即p= p+1。p+1表示以p当前所指向的
位置起始，之后1个元素的地址,即s[2]的地址，然后将s[2]的地址赋给p。
s[2]的地址等价于s+3，因此循环条件p<s+4成立，继续执行循环体
第4次执行循环体
			执行printf(“%c %s\n”,*p,p);即以字符%c形式输出*p所对应的字符。此时p指
向数组中的第4个元素，即s[3],因此*p表示s[3]中的值，即’D’. 然后再以字
符串%s的形式输出以p中地址为首地址的整个字符串，即输出D
			执行完循环体，转向执行表达式3，即p= p+1。p+1表示以p当前所指向的
位置起始，之后1个元素的地址,即s[3]的地址，然后将s[3]的地址赋给p。
s[3]的地址等价于s+4，因此循环条件p<s+4不成立，结束循环

结构体

1.
#include<stdio.h>
struct st 
{
     int x;
 int y;
} a[2]={
    5, 7, 2, 9} ;
main()
{
        
printf("%d\n",a[0].y*a [1].x);
}
运行结果是：
14

首先是定义结构体st，st中共有两个整型成员x，y。
然后定义一个st类型的数组a，a的长度为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的值


       5    a[0].x   a[0]
       7    a[0].y     
       2    a[1].x   a[1]
       9    a[1].y

2.
#include<stdio.h>
main( )
{
    struct stu                             
   {
    int num;
   char a[5];                                
   float score;
}m={
    1234,”wang”,89.5};                  
printf(“%d,%s,%f”,m.num,m.a,m.score);
}
运行结果是：
1234,wang,89.5

3.
#include<stdio.h>
    struct  cmplx
    {
      int  x; 
       int  y;
    } cnum[2]={
    1, 3, 2, 7};
    main( )
    {
      
        printf(“%d\n”, cnum[0].y * cnum[1].x );
    }
运行结果是：6
与第一题解法同
4.
#include <stdio.h>
struct abc
{
     int a, b, c; };
main()
{
     struct abc  s[2]={
    {
    1,2,3},{
    4,5,6}}; 
int t;
  t=s[0].a+s[1].b;
  printf("%d \n",t);
}
运行结果是：6

与第一题解法同
三、	程序填空
1．输入一个字符，判断该字符是数字、字母、空格还是其他字符。
main( )
{
     char ch;
  ch=getchar();
  if(   ch>=’a’&&ch<=’z’|| ch>=’A’&&ch<=’Z’      )
    printf("It is an English character\n");
  else if(   ch>=’0’&&ch<=’9’       )
printf("It is a digit character\n");
else if(   ch== ‘  ’  )
printf("It is a space character\n");
   else          
printf("It is other character\n");  }
第1空：字符在计算机中以ASCII码的形式存储。所以当输入的字符，即ch中字符所对应的ASCII码的范围在英文字母的ASCII码的范围内即可，参照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中字符与空格字符的ASCII码来判断。在判断表达式的值是否相等时，用关系符号==；不要用赋值符号=。

2．下列程序的功能是从输入的整数中，统计大于零的整数个数和小于零的整数个数。用输入0来结束输入，用i,j来放统计数，请填空完成程序。
　　    void main()
        {
        int       n,i=0,j=0;
          printf(“input a integer,0 for end\n”);
          scanf(“%d”,&n);
          while  (  n或n!=0  )   {
     
if(n>0) i=   i+1   ;
              else  j=j+1;
               }
          printf(“i=%4d,j=%4d\n”,i,j);
        }
此题用i来记录大于零的整数，用j记录小于零的整数。所以循环条件是n（或者n!=0）即当n不为0时执行循环体。在循环体中是一个选择语句。如果n>0，则令i加1，相当于令正整数的个数加1；否则（即n<0）,令j加1，相当于令负整数的个数加1。

3．编程计算1＋3＋5+……＋101的值
#include <stdio.h>
void main()
{
    	int i, sum = 0;
	for (i = 1;   i<=101      ;   i=i+2;     )
			sum = sum + i;
	printf("sum=%d\n", sum);  }
for语句的一般形式详见p120.
表达式1为i = 1，为循环变量赋初值，即循环从1开始，本题从1到101，因此终值是101，表达式2是循环条件，用来控制循环的结束，因此循环条件为i<=101；表达式3为循环变量的自增，本题是
4．编程计算1＋3＋5…＋99的值
main()
{
    	  int  i, sum = 0;
i=1;
while (   i<100    )
		{
    	sum = sum + i;
              I=i+2        ;   }
	printf("sum=%d\n", sum);
}
5．从键盘输入一个字符，判断它是否是英文字母。
#include <stdio.h> 
void main()
{
    char  c;
 printf("input a character:"); 
 c=getchar();
if(c>=  ‘A’  &&c<=  ‘Z’  || c>=‘a’ &&c<=  ‘z’)       printf("Yes\n");
 else     printf("No");
}
6. 下面程序的功能是在a数组中查找与x值相同的元素所在位置,请填空。
　　    #include <stdio.h>
        void  main()
         {
     int a[10],i,x;
           printf(“input 10 integers：”);
　　     　for(i=0;i<10;i++) 
scanf(“%d”,&a[i]);
           printf(“input the number you want to find x：”);　
scanf(“%d”,  &x    );
           for(i=0;i<10;i++)
if(  x==a[i]   )
break;
           if(   i<10    ) 
printf(“the pos of x is：%d\n”,i);
           else printf(“can not find x！\n”);
        }
7．程序读入20个整数，统计非负数个数，并计算非负数之和。
   #include <stdio.h>
   main( )
   {
      int  i, a[20], s, count;
     s=count=0;
     for(i=0; i<20; i++)
        scanf(“%d”, &a[i] );
     for(i=0; i<20; i++)
     {
      if( a[i]<0 )    continue  ;
        s+=a[i]  ;
        count++;
     }
     printf(“s=%d\t  count=%d\n”, s, count”);
    }

8. 输入一个正整数n (1<n≤10)，再输入n个整数，用选择法将它们从小到大排序后输出。 
   
#include <stdio.h>
int main(void){
    
    int i, index, k, n, temp;
                                /* 定义1个数组a，它有10个整型元素*/
    printf(“Enter n: ");
                            
    printf(“Enter %d integers: ", n);
    for(i = 0; i < n; i++)  
        scanf("%d", &a[i]);
    for(k = 0; k < n-1; k++){
       /* 对n个数排序 */
        index = k;
        for(                            )  
            if(                )  index = i;    
                                          
    }
    printf("After sorted: ");
    for(i = 0; i < n; i++)      /* 输出n个数组元素的值 */
                              
    return 0;}