带你学C带你飞s1e29课后练习有关return的作用疑问

deerjavu

跪求各位大佬解释下96行return i的作用，已试验注释掉这行也可以正常运行

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

复制代码

人造人

因为myprintf是自己实现printf
printf 调用成功，返回值是实际打印的字符数，所以myprintf也要返回实际打印的字符数
http://bbs.fishc.com/forum.php?m ... peid%26typeid%3D583

fc1735

不知该不该回答，
只是返回传进的的字符串所占的字节，没什么意义。

fc1735

为表示答题诚意，我也自己写了模仿printf()的函数。
跟你写的不同之处在于:printf正确输出时的返回值是输出的总字符数，而你写的是返回待格式化字符串的字符数，即传进的字符串所占字节，并不是处理后输出所占字节。你问返回这个值的用意是什么，就跟你问为什么printf()的返回值是格式化完后输出的字符个数是一样的，我不知道它的返回值能做什么样的应用。

1. #include<stdio.h>
   
2. #include<stdarg.h>
   
3. 
   
4. int format_d(int num);
   
5. int format_s(char* str);
   
6. int myprintf(char* format, ...);
   
7. 
   
8. 
   
9. int format_d(int num)
   
10. {
    
11.         char n[12]={0};
    
12.         char* p=&n[10];
    
13.         int i=11;
    
14.         if (num<0)
    
15.         {
    
16.                 n[0]=1;
    
17.                 num^=-1;
    
18.                 num++;
    
19.         }
    
20.         while ( ( num-= (*p=num%10) ))
    
21.         {
    
22.                 num/=10;
    
23.                 *p--+=48;
    
24.         }
    
25.         *p+=48;
    
26.         if (n[0]) *--p='-';
    
27.         i-=p-n;
    
28.         while (putchar(*p++) );
    
29.         return i;
    
30. }
    
31. 
    
32. int format_s(char* str)
    
33. {
    
34.         char* p=str;
    
35.         while (*p) putchar(*p++);
    
36.         return p-str;
    
37. }
    
38. 
    
39. int myprintf(char* format, ...)
    
40. {
    
41.         int i=0;
    
42.         char* p=format;
    
43.         va_list vap;
    
44.         va_start(vap,format);
    
45.         while (*p)
    
46.         {
    
47.                 if (*p!='%')
    
48.                 {
    
49.                         putchar(*p++);
    
50.                         i++;
    
51.                 }
    
52.                 else
    
53.                 {
    
54.                         switch(*++p)
    
55.                         {
    
56.                                 case 'c':putchar(va_arg(vap, int));
    
57.                                          i++;
    
58.                                          break;
    
59.                                 case 'd':i+=format_d(va_arg(vap, int));
    
60.                                          break;
    
61.                                 case 's':i+=format_s(va_arg(vap, char*));
    
62.                                          break;
    
63.                         }
    
64.                         p++;
    
65.                 }
    
66. 
    
67.         }
    
68.         return i;
    
69. }
    
70. int main()
    
71. {
    
72.         printf("total:%d\n\n",printf("Fishc\n%d\n%c\n%s",12345678,'O',"welcome to fishc\n"));
    
73.         myprintf("total:%d\n\n",printf("Fishc\n%d\n%c\n%s",12345678,'O',"welcome to fishc\n"));
    
74.         myprintf("total:%d\n\n",myprintf("Fishc\n%d\n%c\n%s",12345678,'O',"welcome to fishc\n"));
    
75. 
    
76. 
    
77.         return 0;
    
78. }
    
79. 
    

复制代码

deerjavu

人造人 发表于 2017-1-10 00:12
因为myprintf是自己实现printf
printf 调用成功，返回值是实际打印的字符数，所以myprintf也要返回实际打 ...

谢谢你啊，豁然开朗

deerjavu

fc1735 发表于 2017-1-10 02:46
为表示答题诚意，我也自己写了模仿printf()的函数。
跟你写的不同之处在于:printf正确输出时的返回值是输 ...

也谢谢你啊，打了这么多

deerjavu

fc1735 发表于 2017-1-10 00:36
不知该不该回答，
只是返回传进的的字符串所占的字节，没什么意义。

该回答