一些C代码
1 #include <stdio.h> 2 3 void foo(void) 4 { 5 unsigned int a = 6; 6 int b = -20; 7 (a+b>6)?puts(">6"):puts("<6"); 8 } 9 10 int main(void) 11 { 12 foo(); 13 return 0; 14 }
运行结果：
>6
a+b做了隐式转换，把int转化为unsigned int。编译器就会把b当做一个很大的正数。
下面代码有什么问题，为什么？
1 #include <stdio.h> 2 3 void foo(void) 4 { 5 char string[10],str1[10]; 6 int i; 7 for(i=0;i<10;i++) 8 { 9 str1[i]='a'; 10 } 11 strcpy(string,str1); 12 printf("%s",string); 13 } 14 15 int main(void) 16 { 17 foo(); 18 return 0; 19 }
运行到11行strcpy的时候，可能会产生内存异常。
因为str1没有结束标志符。str1数组后面继续存储的可能不是'\0',而是乱码。
printf函数，对于输出 char * 类型，顺序打印字符串中的字符，知道遇到空字符'\0',或已经打印了由精度指定的字符数为止。
3. 下面代码，i和j的值分别是什么？为什么？
1 #include <stdio.h> 2 3 static int j = 0; 4 int k = 0; 5 6 void fun1(void) 7 { 8 static int i = 0; 9 i++; 10 } 11 12 void fun2(void) 13 { 14 j=0; 15 j++; 16 } 17 18 int main(void) 19 { 20 for(k=0;k<10;k++) 21 { 22 fun1(); 23 fun2(); 24 } 25 return 0; 26 }
i=10，j=1。
由于被 static 修饰的局部变量总是存在内存的静态区，所有即使这个函数运行结束，这个静态变量的值还是不会被销毁，函数下次使用时扔能用到这个值。所以i的值只被初始化了1次。
而j是全局变量，每次调用函数时，j的值都被初始化。
4. 下面代码里，假设在32位系统下，各个sizeof计算的结果分别是什么？
1 #include <stdio.h> 2 3 int *p = NULL; 4 5 int a[100]={0,}; 6 7 int b[100]={0,}; 8 void fun(int b[100]) 9 { 10 printf("sizeof(b)=%d\n",sizeof(b)); 11 } 12 13 int main(void) 14 { 15 printf("sizeof(p)=%d\n",sizeof(p)); 16 printf("sizeof(*p)=%d\n",sizeof(*p)); 17 printf("sizeof(a)=%d\n",sizeof(a)); 18 printf("sizeof(a[100])=%d\n",sizeof(a[100])); 19 printf("sizeof(&a)=%d\n",sizeof(&a)); 20 printf("sizeof(&a[0])=%d\n",sizeof(&a[0])); 21 fun(a); 22 }
32位 decpp运行结果：
sizeof(p)=4 sizeof(*p)=4 sizeof(a)=400 sizeof(a[100])=4 sizeof(&a)=4 sizeof(&a[0])=4 sizeof(b)=4
注意：在VC++6.0中 sizeof(&a)=400。
64位 devcpp运行结果：
sizeof(p)=8 sizeof(*p)=4 sizeof(a)=400 sizeof(a[100])=4 sizeof(&a)=8 sizeof(&a[0])=8 sizeof(b)=8
5. 下面代码结果是什么？为什么？
1 #include <stdio.h> 2 #include <string.h> 3 4 int main(void) 5 { 6 signed char a[1000]; 7 int i; 8 for(i=0;i<1000;i++) 9 { 10 a[i]=-1-i; 11 } 12 printf("%d\n",strlen(a)); 13 return 0; 14 }
输出结果：255
6. 下面代码中，哪些内容可以被改写，哪些不可被改写
1 const int *p; 2 int const *p; 3 int *const p; 4 const int const *p;
const int *p; //p可被改写，p指向的对象不可被改写 int const *p; //p可被改写，p指向的对象不可被改写 int *const p; //p不可被改线，p指向的对象可被改写 const int const *p; //指针p和p指向的对象都不可被改写
8. 在32位x86系统下，输出的值为多少？
1 #include <stdio.h> 2 #include <string.h> 3 4 int main(void) 5 { 6 int a[5]={1,2,3,4,5}; 7 int *ptr1 = (int *)(&a+1); 8 int *prt2 = (int *)((int)a+1); 9 printf("%x,%x\n",ptr1[-1],*prt2); 10 return 0; 11 }
输出： 5,2000000
32位x86存储是小端模式。
ptr1指向数组后面的地址，ptr[-1]则执行a[4].
prt2指向数组a第一个元素的地址值再+1字节的地址。
数组a：低地址 01000000 02000000 03000000 04000000 05000000
| | |
ptr2 ptr1-1 ptr1
9. 0x01<<2+3 的值是多少？为什么？
32，因为+的优先级比移位运算符的优先级高
10. 定义一个宏，求x的平方。
#define POW(x) ((x)*(x))
注意括号
11.下面两个代码有什么区别？
1 struct TestStruct1{ 2 char c1; 3 short s; 4 char c2; 5 int i; 6 }st1; 7 8 9 struct TestStruct2{ 10 char c1; 11 char c2; 12 short s; 13 int i; 14 }st2;
sizeof(st1)=12， 占12字节内
sizeof(st2)=8，占8字节内存
12. 写代码，想内存0x12ff7c地址处存入一个整形术0x100。
int *p = (int *)0x12ff7c; *p = 0x100;
或者
*(int*)0x12ff7c = 0x100;
13. 下面代码值是多少？
1 #include <stdio.h> 2 #include <string.h> 3 4 int main(void) 5 { 6 int a[5]={1,2,3,4,5}; 7 int *ptr = (int *)(&a+1); 8 printf("%d,%d\n",*(a+1),*(ptr-1)); 9 10 return 0; 11 }
结果为： 2,5
a作为右值，与&a[0] 一样，表示数组第一个元素的地址，*(a+1) 表示 a[1]
而 &a，表示数组的地址，&a+1，指针指针移动的大小为整个数组大小 5*sizof(int)个字节。*(ptr-1) 表示a[4]。
enum
1 #include <stdio.h> 2 3 enum Color 4 { 5 GREEN = 1, 6 RED, 7 BLUE, 8 GREEN_RED=10, 9 GREEN_BLUE 10 }ColorVal; 11 12 int main(void) 13 { 14 printf("sizeof(ColorVal)=%d\n",sizeof(ColorVal)); 15 printf("GREEN=%d\n",GREEN); 16 printf("RED=%d\n",RED); 17 printf("BLUE=%d\n",BLUE); 18 printf("GREEN_RED=%d\n",GREEN_RED); 19 printf("GREEN_BLUE=%d\n",GREEN_BLUE); 20 return 0; 21 }
运行结果：
sizeof(ColorVal)=4 GREEN=1 RED=2 BLUE=3 GREEN_RED=10 GREEN_BLUE=11
enum变量类型可以给其中的常量符号赋值，如果不赋值则会从被赋初始值的那个常量开始依次+1；如果都没有赋值，它们的值从0开始依次+1。
