码迷,mamicode.com
首页 > 其他好文 > 详细

一些C代码

时间:2019-09-15 11:13:02      阅读:109      评论:0      收藏:0      [点我收藏+]

标签:指针   c代码   ati   str   静态   结果   for   val   ++   

 

 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。

 

一些C代码

标签:指针   c代码   ati   str   静态   结果   for   val   ++   

原文地址:https://www.cnblogs.com/doitjust/p/11521122.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!