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
1328
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
