关于函数调用、静态变量、预编译的习题

悠悠 2023-02-11 12:26 11阅读 0赞

《程序设计基础-c语言》杨莉 刘鸿翔  
    ISBN-978-7-03-032903-5  
    p238-240
    习题7

1.程序阅读，写出程序的运行结果

/* (1) */
    #include<stdio.h>
    int f(int x)
    { 
        static int k=0;
        x+=k++;
        return x;
    }
    void main()
    { 
        printf("%d\n",f(f(1)));
    }

![在这里插入图片描述][20200523184832724.png]  
分析：

1.  函数从main函数开始，`f(f(1))`函数被调用2次
2.  第一次：`1`的值给形参`x`，定义局部静态变量k等于0，`x=x + k++`【值为1+0】赋给`x`，`返回x`【值为1】；
3.  静态变量的值已定义，函数调用结束，值保留，在下一次调用时，再使用,此时k的值为`1`
4.  第二次：`f(1)`【值为1】的值传给形参`x`，`x = x + k++`【值为1+1】赋给`x`，返回`x`【值为2】

/* (2) */
    #include<stdio.h>
    int c,a=4;
    func(int a,int b)
    { 
        c=a*b;
        a=b-1;
        b++;
        return (a+b+1);
    }
    void main()
    { 
        int b=2,p=0;
        c=1;
        p=func(b,a);
        printf("%d,%d,%d,%d\n",a,b,c,p);
        system("pause");
    }

![在这里插入图片描述][20200523194002732.png]  
分析：

1.  执行`p=func(b,a);`调用func函数，`实参b`–>`形参a`，`实参a`–>`形参b`
2.  执行`c=a*b`，**全局变量**`c`的值为2\*4=`8`
3.  执行`a=b-1`，**形参**`a`的值4-1=`3`
4.  再执行`b++`，**形参**`b`的值b自增为`5`
5.  执行`return (a+b+1);`返回3+5=`8`；
6.  函数调用结束，形参a，b的占用的地址被释放
7.  **main函数**输出**全局变量**`a`=`4`，主函数的**局部变量**`b`=`2`，**全局变量**`c`=`8`，主函数的**局部变量**`p`=3+5+1=`9`

/* (3) */
    #include<stdio.h>
    void num()
    { 
        extern int x,y;
        int a=15,b=10;
        x=a-b;
        y=a+b;
    }
    int x,y;
    void main()
    { 
        int a=7,b=5;
        x=a+b;
        y=a-b;
        num();
        printf("%d,%d\n",x,y);
    }

![在这里插入图片描述][2020052319562052.png]  
分析：

1.  先算出主函数中`x`，`y`的值`x=12`，`y=2`
2.  再调用一次`num函数`，外部变量`x`，`y`的值被覆盖
3.  计算后`x=5`，`y=25`

/* (4) */
    #include<stdio.h>
    int n=1;
    void func()
    { 
        static int x=4;
        int y=10;
        x=x+2;
        n=n+10;
        y=y+n;
        printf("FUNC：x=%2d,y=%2d,n=%2d\n",x,y,n);
    }
    void main()
    { 
        static int x=5;
        int y=n;
        printf("MAIN：x=%2d,y=%2d,n=%2d\n",x,y,n);
        func();
        printf("MAIN：x=%2d,y=%2d,n=%2d\n",x,y,n);
        func();
    }

![在这里插入图片描述][20200523201225754.png]  
分析：

1.  定义局部静态变量`x`=`5`，局部变量`y`=全局变量`n`=`1`，输出5,1,1
2.  调用`func`函数，定义局部静态变量`x`=`4`，局部变量`y`=`10`，`x`=4+2=`6`，`n`=1+10=`11`，`y`=10+11=`21`，输出6,21,11；**局部变量y的地址释放，n的值11保留**
3.  在主函数输出x，y，n；`x`=`5`，为`主函数的局部静态变量x`；`y`=`1`，为主`函数的局部变量y`；`n`=`11`，为`全局变量n`，输出5,1,11
4.  调用`func`函数，`x`=6+2=`8`，`n`=21+10=`31`，`y`=10+11=`21`，输出8,31,21

/* (5) */
    #include<stdio.h>
    #define XYZ "String_XYZ"
    main()
    { 
        printf("XYZ=%s, %s\n",XYZ,"XYZ");
    }

![在这里插入图片描述][20200523203759679.png]  
分析：

1.  宏展开时把`XYZ`替换为字符串`String_XYZ`
2.  第二个`%s`，直接输出`XYZ`
3.  因为对程序中用**双括号括起来的字符串内的字符**，即使与宏名相同，也**不进行置换**

/* (6) */
    #define MIN(x,y) (x)<(y)?(x):(y)
    main()
    { 
        int i,j,k;
        i=10;
        j=15;
        k=10*MIN(i,j);
        printf("%d\n",k);
    }

![在这里插入图片描述][20200523204502357.png]  
分析：

1.  宏展开后该语句为： `10*(i) < (j) ? (i) : (j)`，运算结束的结果为`15`

/* (7) */
    #include "stdio.h"
    #define FUDGF(y) 2.84+y
    #define PR(a) printf("%d",(int)(a));
    #define PRINT1(a) PR(a);putchar("\n")
    main()
    { 
        int x=2;
        PRINT1(FUDGF(5)*x);
    }

![在这里插入图片描述][2020052321041191.png]  
分析：

1.  `2.84+5*2=12.84`,取`int` =`12`

[20200523184832724.png]: https://img-blog.csdnimg.cn/20200523184832724.png
[20200523194002732.png]: https://img-blog.csdnimg.cn/20200523194002732.png
[2020052319562052.png]: https://img-blog.csdnimg.cn/2020052319562052.png
[20200523201225754.png]: https://img-blog.csdnimg.cn/20200523201225754.png
[20200523203759679.png]: https://img-blog.csdnimg.cn/20200523203759679.png
[20200523204502357.png]: https://img-blog.csdnimg.cn/20200523204502357.png
[2020052321041191.png]: https://img-blog.csdnimg.cn/2020052321041191.png