一些C代码

Posted 2022-11-01 doitjust

 

 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

 

 

 

 

 

 

 

 

 

 

 

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。