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

2. 求程序的运行结果

#include

main()

{

short int m=32767, n=032767;

printf("%d, %o \n", m, n);

return 0;

}

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

#include

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

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

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

(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

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

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

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

#include

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

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

#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

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

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

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

int *f(int *x, int *y)

{

if(*x

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

main()

{

char *s[] = { "one", "two", "three" }, *p;

p = s[1];

printf("%c %s \n", *(p+1), s[0]);

return 0;

}

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

#include

union

{

unsigned int n;

unsigned char c;

}u;

main()

{

u.c=‘A‘;

printf("%c \n", u.n);

return 0;

}

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

#include

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

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

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