[已解决]带你学c带你飞第一季课后题29

勿忘心安l

#include <stdio.h>
#include <string.h>
#include <stdarg.h>

int myprintf(char *format, ...);
int countInt(int num);
void printInt(int num);
void printStr(char *str);

// 这里我们使用迭代的方式打印整数
// 等后面学了递归，用递归会更方便呢
void printInt(int num)
{
        int dec = 1;
        int temp;

        if (num < 0)
        {
                putchar('-');
                num = -num;
        }

        temp = num;

        while (temp > 9)
        {
                dec *= 10;
                temp /= 10;
        }        

        while (dec != 0)
        {
                putchar(num / dec + '0');
                num = num % dec;
                dec /= 10;
        }
}

// 计算整数占多少个字符
int countInt(int num)
{
        int count = 0;

        if (num < 0)
        {
                count++;
                num = -num;
        }

        do
        {
                count++;
        } while (num /= 10);

        return count;
}

void printStr(char *str)
{
        int i = 0;

        while (str[i] != '\0')
        {
                putchar(str[i]);
                i++;
        }
}

int myprintf(char *format, ...)
{
        int i = 0;
        int count = 0;
        int darg;
        char carg;
        char *sarg;
        va_list vap;

        va_start(vap, format);

        while (format[i] != '\0')
        {
                // 如果不是格式化占位符，直接打印字符串
                if (format[i] != '%')
                {
                        putchar(format);
                        i++;
                        count++;
                }
                // 如果是格式化占位符...
                else
                {
                        switch (format[i+1])
                        {
                                case 'c':
                                        {
                                                carg = va_arg(vap, int);
                                                putchar(carg);
                                                count++;
                                                break;
                                        }
                                case 'd':
                                        {
                                                darg = va_arg(vap, int);
                                                printInt(darg);
                                                count += countInt(darg);
                                                break;
                                        }
                                case 's':
                                        {
                                                sarg = va_arg(vap, char *);
                                                printStr(sarg);
                                                count += strlen(sarg);
                                                break;
                                        }
                        }
                        i += 2;
                }
        }

        va_end(vap);

        return count;
}

int main(void)
{
        int i;

        i = myprintf("Hello %s\n", "FishC");
        myprintf("共打印了%d个字符(包含\\n)\n", i);
        i = myprintf("int: %d, char: %c\n", -520, 'H');
        myprintf("共打印了%d个字符(包含\\n)\n", i);
        
        return 0;
}[/i][/i][/i][/i]



课后题29， 为什么case'c'后面的carg = va_arg(vap, int);只能用int的格式来传输？

最佳答案

月排行榜 / 总排行榜

就是要努力呀

2020-4-4 21:02:05

勿忘心安l 发表于 2020-4-4 15:41
代码在这里，用int我知道可以，但是我这里把int改成char就会报错。这是为什么，我感觉按道理来说ch ...

百度了一下明白了，va_arg()中的数值类型不能为：
——char、signed char、unsigned char
——short、unsigned short
——signed short、short int、signed short int、unsigned short int
——float

char和short类型的参数会被转换为int类型，而float类型的参数会被转换为double类型

参考链接
https://blog.csdn.net/major2007/article/details/6224515

跳转到最佳答案楼层

就是要努力呀

va_arg(参数列表, 参数值类型)  获取参数值

用你的代码编译不了，有几处报错，就不做实验了，以下是我的猜测

如果你要获取的是一个字符，我认为里面是 char 或者 int 都可以，如果里面是int， 再碰到字符时这个宏定义就获取字符的ascii码，再返回给你的carg，但是因为carg是一个字符类型，他就会获取这个ascii对应的字符，类似于 char c = 49 最后c的值是 '1'

勿忘心安l

就是要努力呀 发表于 2020-4-4 11:07
va_arg(参数列表, 参数值类型)  获取参数值

用你的代码编译不了，有几处报错，就不做实验了，以下是我的 ...

1. #include <stdio.h>
   
2. #include <string.h>
   
3. #include <stdarg.h>
   
4. 
   
5. int myprintf(char *format, ...);
   
6. int countInt(int num);
   
7. void printInt(int num);
   
8. void printStr(char *str);
   
9. 
   
10. // 这里我们使用迭代的方式打印整数
    
11. // 等后面学了递归，用递归会更方便呢
    
12. void printInt(int num)
    
13. {
    
14.         int dec = 1;
    
15.         int temp;
    
16. 
    
17.         if (num < 0)
    
18.         {
    
19.                 putchar('-');
    
20.                 num = -num;
    
21.         }
    
22. 
    
23.         temp = num;
    
24. 
    
25.         while (temp > 9)
    
26.         {
    
27.                 dec *= 10;
    
28.                 temp /= 10;
    
29.         }        
    
30. 
    
31.         while (dec != 0)
    
32.         {
    
33.                 putchar(num / dec + '0');
    
34.                 num = num % dec;
    
35.                 dec /= 10;
    
36.         }
    
37. }
    
38. 
    
39. // 计算整数占多少个字符
    
40. int countInt(int num)
    
41. {
    
42.         int count = 0;
    
43. 
    
44.         if (num < 0)
    
45.         {
    
46.                 count++;
    
47.                 num = -num;
    
48.         }
    
49. 
    
50.         do
    
51.         {
    
52.                 count++;
    
53.         } while (num /= 10);
    
54. 
    
55.         return count;
    
56. }
    
57. 
    
58. void printStr(char *str)
    
59. {
    
60.         int i = 0;
    
61. 
    
62.         while (str[i] != '\0')
    
63.         {
    
64.                 putchar(str[i]);
    
65.                 i++;
    
66.         }
    
67. }
    
68. 
    
69. int myprintf(char *format, ...)
    
70. {
    
71.         int i = 0;
    
72.         int count = 0;
    
73.         int darg;
    
74.         char carg;
    
75.         char *sarg;
    
76.         va_list vap;
    
77. 
    
78.         va_start(vap, format);
    
79. 
    
80.         while (format[i] != '\0')
    
81.         {
    
82.                 // 如果不是格式化占位符，直接打印字符串
    
83.                 if (format[i] != '%')
    
84.                 {
    
85.                         putchar(format[i]);
    
86.                         i++;
    
87.                         count++;
    
88.                 }
    
89.                 // 如果是格式化占位符...
    
90.                 else
    
91.                 {
    
92.                         switch (format[i+1])
    
93.                         {
    
94.                                 case 'c':
    
95.                                         {
    
96.                                                 carg = va_arg(vap, int);
    
97.                                                 putchar(carg);
    
98.                                                 count++;
    
99.                                                 break;
    
100.                                         }
     
101.                                 case 'd':
     
102.                                         {
     
103.                                                 darg = va_arg(vap, int);
     
104.                                                 printInt(darg);
     
105.                                                 count += countInt(darg);
     
106.                                                 break;
     
107.                                         }
     
108.                                 case 's':
     
109.                                         {
     
110.                                                 sarg = va_arg(vap, char *);
     
111.                                                 printStr(sarg);
     
112.                                                 count += strlen(sarg);
     
113.                                                 break;
     
114.                                         }
     
115.                         }
     
116.                         i += 2;
     
117.                 }
     
118.         }
     
119. 
     
120.         va_end(vap);
     
121. 
     
122.         return count;
     
123. }
     
124. 
     
125. int main(void)
     
126. {
     
127.         int i;
     
128. 
     
129.         i = myprintf("Hello %s\n", "FishC");
     
130.         myprintf("共打印了%d个字符(包含\\n)\n", i);
     
131.         i = myprintf("int: %d, char: %c\n", -520, 'H');
     
132.         myprintf("共打印了%d个字符(包含\\n)\n", i);
     
133.         
     
134.         return 0;
     
135. }

复制代码

代码在这里，用int我知道可以，但是我这里把int改成char就会报错。这是为什么，我感觉按道理来说char应该也可以啊。

就是要努力呀

勿忘心安l 发表于 2020-4-4 15:41
代码在这里，用int我知道可以，但是我这里把int改成char就会报错。这是为什么，我感觉按道理来说ch ...

百度了一下明白了，va_arg()中的数值类型不能为：
——char、signed char、unsigned char
——short、unsigned short
——signed short、short int、signed short int、unsigned short int
——float

char和short类型的参数会被转换为int类型，而float类型的参数会被转换为double类型

参考链接
https://blog.csdn.net/major2007/article/details/6224515

勿忘心安l

就是要努力呀 发表于 2020-4-4 21:02
百度了一下明白了，va_arg()中的数值类型不能为：
——char、signed char、unsigned char
——short ...

感谢！