二级C语言真题笔记

二级C语言真题笔记

1. 知识重点：数据类型、循环、数组、函数、指针、结构体与共同体

2. 求程序的运行结果

 
#include <stdio.h>
 
main()
{
    short int m=32767, n=032767;
    printf("%d, %o \n", m, n);
    return 0;
}

3. 自增和自减运算符的运算对象可以为char, int, float

 
#include <stdio.h>
 
main()
{
    float scanf = 9.12345678; 
    // warning C4305: 'initializing' : truncation from 'const double' to 'float'
    
    double main = 9.12345678;
 
    printf("%.10f \n", scanf++); // 9.1234569550
    printf("%.10f \n", scanf); // 10.1234569550
 
    printf("%.10f \n", main++); // 9.1234567800
    printf("%.10f \n", main); // 10.1234567800
 
    return 0;
}

4. 求运行结果

 
#include <stdio.h>
 
main()
{
    char a, b, *c;
    //a = '\'; //错误。正确的转义形式为：a = '\\';
    a = '\ '; //正确。
    b = '\x31'; //表示ASCII码为49的字符，也即字符'1'
    c = "\0157"; //指针c指向的字符串为"\r7"，它包含一个回车符，一个字符'7'，和一个'\0'
    printf("%c, %c, %s \n", a, b, c);
 
    return 0;
}

5. C语言中没有以B结尾的二进制整数常量，如 int x = 101011B; 是不对的

6. 不能定义为用户标识符的是：(  )

(A) scanf    (B) Void    (C) _3com_    (D) int

注：用户标识符只能由字母、数字和下划线组成，且第一个字符必须为字母或下划线，C语言中的关键字(保留字)不能用于用户标识符。D选项为关键字，所以不能作用户标识符。

7. 以下为非法表达式的是：(  )

(A) 0<=x<100    (B) i=j==0    (C) (char) (65+3)    (D) x+1=x+1

注：不能对表达式进行赋值。

8. 写出运行结果：

 
#include <stdio.h>
 
main()
{
    int a;
    char c = 10;
    float f = 110.0;
    double x;
 
    a=f/=c*=(x=6.5);
 
    printf("%d %d %3.2f %3.1f %3.1f\n",a,c,f,f,x); 
 
    return 0;
}

注：赋值运算符的结合性为从右向左结合；输出中的精度控制会产生四舍五入。

9. 运算符的优先级，如：

(1) k=(n=b>a)||(m=a<b)，先做两个括号内的表达式，再将两个表达式的结果做||运算，再将运算结果赋值给k。

(2) 0<=x<100，关系运算符从左往右结合，所以先判断0<=x，再将判断结果与100比较。整个表达式的值总是为真。

(3) i=j==0，先判断变量j是否等于0，再将判断结果赋值给变量i，因此变量i的值或为0，或为1。

(4) a>b>c

(5) (c-1>=d)==1

注：在整个优先级中，逗号运算符的优先级最低，其次是赋值运算符。关系运算符的优先级高于赋值运算符。

如下为常用运算符的优先级，逗号运算符的优先级最低，圆括号的优先级最高。未写结合性的为从左往右结合：

( )  (圆括号)

++  --  *(指针)  &(取地址)          结合性：R -> L

*  /  % (乘，除，取余)

+  - (加，减)

<  <=  >  >=  (关系运算符)

==  !=  (等于，不等于)

&&  (逻辑与)

||  (逻辑或)

=   +=   -=   *=   /=   %=   >>=   <<=   &=   ^=   !=  (简单赋值和复合赋值运算符)       结合性：R -> L

,  (逗号运行符)

10. 将x中的值保留到小数点后两位，并将第三位四舍五入

float x=1.236;
x=(int)(x*100+0.5)/100.0;
printf("%f \n", x); //1.240000

11. (1) 取余运算符%两边必须是整数；

(2) 赋值运算符=左边必须是变量，不能是常量或表达式；

(3) #define n 2 后，n为符号常量；

(4) 当除号 / 两边的运算对象都是整型时，为整除，即结果的小数部分被忽略掉。

12. 写出程序结果

 
#include <stdio.h>
 
main()
{
    char a = 'D'-'A'+'0';
    printf("%c \n", a);
 
    /* 以下为附加内容 */
    printf("%c %d \n", 'z'-'A', 'z'-'A'); //9 57
    printf("%c %c %c %d \n", '0', '\0', '\000', '0'); //0    48
    printf("%c %d \n", a, a); //3 51
 
    return 0;
}

注：字符'0'的ASCII码值是十进制的48，或十六进制的30

13. 输入12<回车>，请写出程序的运行结果

 
#include <stdio.h>
 
main()
{
    char ch1, ch2;
    int n1, n2;
 
    ch1 = getchar(); 
    ch2 = getchar();
 
    n1 = ch1 - '0';
    n2 = n1*10 + (ch2 -'0');
 
    printf("%d \n", n2);
 
    return 0;
}

14. 写程序运行结果：

 
#include <stdio.h>
 
main()
{
    int i;
    for(i=0; i<3; i++)
        switch(i)
    {
        case 1: printf("%d", i);
        case 2: printf("%d", i);
        default: printf("%d", i);
    }
 
    return 0;
}

15. 与 k=a>b?(b>c?1:0):0；功能等价的是：(  )

(A) if((a>B) &&(b>C) ) k=1;   (B)  if((a>B) ||(b>C) )  k=1
　　　　　　　　　　　　　　　　　 else  k=0;
(C) if(a<=B)   k=0;           　 (D) if(a>B)   k=1;
     else if(b<=C)   k=1;            　　else if(b>C)   k=1;
                                   　　　　　　　else k=0;

16. int N=5, b[N][N]; 是错误的。数组长度应为常量，不能动态定义数组长度。

17. 写出程序运行结果

 
#include <stdio.h>
#include <string.h>
 
main()
{
    char s1[ ] = "\n123\\";
    char s2[8] = "\n123\\";
 
    printf("%d %d ", strlen(s1), sizeof(s1));
    printf("%d %d \n", strlen(s2), sizeof(s2));
 
    return 0;
}

注：考查转义字符，空字符'\0'，strlen库函数和sizeof操作符的用法

18. 以下正确的是：( D )

(A) char s[8]; s = {"Beijing"};

(B) char s[8]; s = "Beijing";

(C) char *s;   s = {"Beijing"};

(D) char *s;   s = "Beijing";

注：{"Beijing"}的表达方式只能在字符串定义时初始化。对于B，数组名s存储的是该数组的首地址，为一个常量，不能对其赋值。对于D，是将字符串的首地址赋给指针变量s，是对的。

19. 写出程序的输出结果

 
#include <stdio.h>
 
main()
{
    int a[3][3], *p, i;
    p = &a[0][0];
    for(i=0; i<9; i++)
        p[i] = i+1;
    printf("%d \n", a[1][2]);
 
    return 0;
}

注：考查二维数组在内存中的存放方式以及指针的正确使用。

20. 输入一个含有数字的字符串，输出数字部分。如输入abc123kkkj456，则输出123456。

 
#include <stdio.h>
#define N 30
 
main()
{
    int i, j;
    char src[N], dest[N];
 
    gets(src);
    for(i=j=0; src[i]!='\0'; i++)
        if(src[i]>='0' && src[i]<='9')
        {
            dest[j]=src[i];
            j++;
        }
    dest[j]='\0';
    puts(dest);
 
    return 0;
}

21. 全局变量，局部变量，变量的存储类型，变量作用域(空间角度)，生存期(时间角度)

局部变量：函数内部定义。如主函数定义的局部变量的作用范围仅限于主函数及调用函数

全局变量：函数外部定义。作用范围从定义开始到源文件结束。

全局变量在一个文件中定义，在别一个文件中引用时，要用extern进行说明。这时该变量的作用域可扩展到有extern说明的其它源文件。若不希望该全局变量在其它文件中被引用，可加static进行限定。

按生存期可分为静态和动态变量。

没有对static变量赋初值时，系统自动赋值。如static int x; 系统自动赋值0。auto变量为随机值。

static变量的生存期贯穿于整个程序运行期间。

函数形参都属于局部变量。

当函数或复合语句中的局部变量与全局变量同名时，全局变量无效。

22. 将以下程序编译连接后生成一个text.exe文件，进入MS-DOS窗口，切入该文件所在目录，输入test.exe abc<回车>。请写出运行结果：

 
#include <stdio.h>
 
int func()
{
    static int s=0;
    s+=1;
    return s;
}
 
main(int argc, char *argv[])
{
    int n, i=0;
    while(argv[1][i] != '\0')
    {
        n=func();
        i++;
    }
    printf("%d \n", n*argc);
 
    return 0;
}

注：局部静态变量只初始化一次，在以后的调用当中不再进行初始化。

23. 写出程序运行结果

 
#include <stdio.h>
 
void func( int *a )
{
    a[0] = a[1];
}
 
main()
{
    int a[10]={1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, i;
    for(i=2; i>=0; i--)
        func(&a[i]);
    printf("%d \n", a[0]);
 
    return 0;
}

24. 写出程序运行结果

 
#include <stdio.h>
 
int a=2;
 
int f(int *a)
{
    return *a++; /* 注意运算符的优先级 */
    printf("a=%d", a); 
}
 
main()
{
    int s=0;
    {
        int a=5;
        s+=f(&a);
        printf("locala=%d ", a);
    }
    s+=f(&a);
    printf("globala=%d ", a);
    printf("s=%d \n", s);
 
    return 0;
}

25.

int *q;

q=NULL; q指向地址为0的单元

*q=0;  对该单元赋值没有意义

26. 函数的返回值类型为指针

 
#include <stdio.h>
 
int *f(int *x, int *y)
{
    if(*x<*y)
        return x;
    else
        return y;
}
 
main()
{
    int a=7, b=8, *p, *q, *r;
    p=&a;
    q=&b;
    r=f(p, q);
    printf("%d %d %d \n", *p, *q, *r);
 
    return 0;
}

27. 写出程序运行结果

 
#include <stdio.h>
 
main()
{
    char *s[] = { "one", "two", "three" }, *p;
    p = s[1];
    printf("%c %s \n", *(p+1), s[0]);
 
    return 0;
}

28. 写出以下程序运行结果

 
#include <stdio.h>
 
union
{
    unsigned int n;
    unsigned char c;
}u;
 
main()
{
    u.c='A';
    printf("%c \n", u.n);
 
    return 0;
}

29. *++p, ++*p, *p++的区别

 
#include <stdio.h>
 
main()
{ 
    int a[10] = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100}, *p=&a[0];
 
    printf("%d %d %d %d \n", *p, *p++, *p++, *p);
    printf("%d %d %d %d \n", *p, *p++, *p++, *p);
    printf("%d %d %d %d \n", *p, *++p, *++p, *p);
    printf("%d %d %d %d \n", *++p, ++*p, *p++, *p);
 
    return 0;
}

 
#include <stdio.h>
 
main()
{ 
    int a[5] = {1, 2, 3, 4, 5}, *p=&a[0];
 
    printf("%d %d %d %d \n", *++p, ++*p, *p++, *p);
    printf("%d %d %d %d \n", *++p, ++*p, *p++, *p);
 
    return 0;
}

两个版本的字符串复制函数 _CRTIMP char *  __cdecl strcpy(char *, const char *) 对比：

版本1：

 
strcpy(char * dest, const char * src)
{
    char *p=dest;
    while(*dest++ = *src++)
        ;
    dest=p;
}

版本2：

 
strcpy(char * dest, const char * src)
{
    int i=0;
    for(; *(src+i)!='\0'; i++)
        *(dest+i) = *(src+i);
    *(dest+i) = '\0';
}

注：指针运算符*, 自增运算符++是从右往左结合的；

实例：

 
#include <stdio.h>
 
strcpy_v1(char * dest, const char * src)
{
    char *p=dest;
    while(*dest++ = *src++)
        ;
    dest=p;
}
 
strcpy_v2(char * dest, const char * src)
{
    int i=0;
    for(; *(src+i)!='\0'; i++)
        *(dest+i) = *(src+i);
    *(dest+i) = '\0';
}
 
main()
{ 
    char a[]="abcd";
    char b[]="abc";
    strcpy_v1(a, b);
    puts(a);
 
    char c[]="abcd";
    char d[]="abc";
    strcpy_v2(c, d);
    puts(d);
 
    return 0;
}

输出：

abc
abc

参考答案：

2. 32767, 32767

3. 7  1,

6. D

7. D

8. 1 65 1.69 1.7 6.5

12. 3

13. 12

14. 011122

15. A

17. 5 6 5 8

19. 6

22. 6

23. 4

24. 7

26. 7 8 7

27. w one

28. A

29.

10 10 10 10
30 30 30 30
70 70 60 50
80 71 70 70

2 2 1 1
4 4 3 3