1. 知识重点：数据类型、循环、数组、函数、指针、结构体与共同体
2. 求程序的运行结果
main()
{
short int m=32767, n=032767;
printf("%d, %o \n", m, n);
return 0;
}
3. 自增和自减运算符的运算对象可以为char, int, float
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. 求运行结果
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. 写出运行结果：
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中的值保留到小数点后两位，并将第三位四舍五入
x=(int)(x*100+0.5)/100.0;
printf("%f \n", x); //1.240000
11. (1) 取余运算符%两边必须是整数；
(2) 赋值运算符=左边必须是变量，不能是常量或表达式；
(3) #define n 2 后，n为符号常量；
(4) 当除号 / 两边的运算对象都是整型时，为整除，即结果的小数部分被忽略掉。
12. 写出程序结果
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<回车>，请写出程序的运行结果
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. 写程序运行结果：
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 <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. 写出程序的输出结果
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。
#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<回车>。请写出运行结果：
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. 写出程序运行结果
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. 写出程序运行结果
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. 函数的返回值类型为指针
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. 写出程序运行结果
main()
{
char *s[] = { "one", "two", "three" }, *p;
p = s[1];
printf("%c %s \n", *(p+1), s[0]);
return 0;
}
28. 写出以下程序运行结果
union
{
unsigned int n;
unsigned char c;
}u;
main()
{
u.c=‘A‘;
printf("%c \n", u.n);
return 0;
}
29. *++p, ++*p, *p++的区别
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;
}
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：
{
char *p=dest;
while(*dest++ = *src++)
;
dest=p;
}
版本2：
{
int i=0;
for(; *(src+i)!=‘\0‘; i++)
*(dest+i) = *(src+i);
*(dest+i) = ‘\0‘;
}
注：指针运算符*, 自增运算符++是从右往左结合的；
实例：
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