home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Interactive Reference Guide / C-C++ Interactive Reference Guide.iso / c_ref / csource2 / sclib_1 / 1_1 / v7n1033a.txt < prev    next >
Encoding:
Text File  |  1995-11-01  |  3.4 KB  |  259 lines
  1. /* stdarg example with prototypes */
  2.  
  3. #include <stdio.h>
  4.  
  5. int maxi(int, ...);
  6.  
  7. main()
  8. {
  9.     printf("-> %d\n", maxi(4, 10, 20, -5, 17));
  10.     printf("-> %d\n", maxi(3, -10, -5, -17));
  11.  
  12. /* is type of second argument int or long? */
  13.  
  14.     printf("-> %d\n", maxi(3, 65432, -5, -17));
  15.  
  16. /* call maxi with count too small or too big */
  17.  
  18.     printf("-> %d\n", maxi(2, 10, -5, 17));
  19.     printf("-> %d\n", maxi(4, 10, -5, 17));
  20. }
  21.  
  22. #include <stdarg.h>
  23. #include <limits.h>
  24.  
  25. int maxi(int parmn, ...)
  26. {
  27.     va_list ap;
  28.     int i, j;
  29.     int max = INT_MIN;
  30.  
  31.     va_start(ap, parmn);
  32.     printf("%2d: ", parmn);
  33.  
  34.     for (j = 1; j <= parmn; ++j) {
  35.         i = va_arg(ap, int);
  36.         printf("%d, ", i);
  37.         if (max < i)
  38.             max = i;
  39.     }
  40.  
  41.     va_end(ap);
  42.     return (max);
  43. }
  44.  
  45.  4: 10, 20, -5, 17, -> 20
  46.  3: -10, -5, -17, -> -5
  47.  3: -104, 0, -5, -> 0
  48.  2: 10, -5, -> 10
  49.  4: 10, -5, 17, 250, -> 250    /* ??? */
  50.  
  51.  
  52.  
  53.  
  54.  
  55. /* stdarg example without prototypes */
  56.  
  57. #include <stdio.h>
  58.  
  59. int maxi();
  60.  
  61. main()
  62. {
  63.     /* ... */
  64. }
  65.  
  66. #include <stdarg.h>
  67. #include <limits.h>
  68.  
  69. int maxi(parmn)
  70. int parmn;
  71. {
  72.     /* ... */
  73. }
  74.  
  75.  
  76.  
  77.  
  78.  
  79. /* varargs solution */
  80.  
  81. #include <stdio.h>
  82.  
  83. int maxi();
  84.  
  85. main()
  86. {
  87.     /* ... */
  88. }
  89.  
  90. #include <varargs.h>
  91. #include <limits.h>
  92.  
  93. int maxi(va_alist)
  94. va_list va_alist;
  95. /* or
  96. va_decl
  97. */
  98. {
  99.     va_list ap;
  100.     int i, j, k;
  101.     int max = INT_MIN;
  102.  
  103.     va_start(ap);
  104.     k = va_arg(ap, int);
  105.     printf("%2d: ", k);
  106.  
  107.     for (j = 1; j <= k; ++j) {
  108.         i = va_arg(ap, int);
  109.         printf("%d, ", i);
  110.         if (max < i)
  111.             max = i;
  112.     }
  113.  
  114.     va_end(ap);
  115.     return (max);
  116. }
  117.  
  118.  4: 10, 20, -5, 17, -> 20
  119.  3: -10, -5, -17, -> -5
  120.  3: -104, 0, -5, -> 0
  121.  2: 10, -5, -> 10
  122.  4: 10, -5, 17, 449, -> 449    /* ??? */
  123.  
  124.  
  125.  
  126.  
  127.  
  128. /* handling a variable number of values via an array */
  129.  
  130. #include <stdio.h>
  131. #include <stddef.h>
  132.  
  133. int maxi1(size_t, int *);
  134.  
  135. main()
  136. {
  137.     static int array[5] = {4, 10, -7, 17, 20};
  138.     size_t i;
  139.  
  140.     for (i = 1; i <= sizeof(array)/sizeof(int); ++i)
  141.         printf("-> %d\n", maxi1(i, array));
  142. }
  143.  
  144. #include <limits.h>
  145.  
  146. int maxi1(size_t count, int table[])
  147. {
  148.     size_t i;
  149.     int max = INT_MIN;
  150.  
  151.     for (i = 0; i < count; ++i) {
  152.         printf("%d, ", table[i]);
  153.         if (max < table[i])
  154.             max = table[i];
  155.     }
  156.  
  157.     return (max);
  158. }
  159.  
  160. 4, -> 4
  161. 4, 10, -> 10
  162. 4, 10, -7, -> 10
  163. 4, 10, -7, 17, -> 17
  164. 4, 10, -7, 17, 20, -> 20
  165.  
  166.  
  167.  
  168.  
  169.  
  170.  
  171. /* handling arguments with varying types */
  172.  
  173. #include <stdio.h>
  174.  
  175. int output(char *, ...);
  176.  
  177. main()
  178. {
  179.     output("S D C\nS X F E\n", "abcd", 123, 'A',
  180.         "xyz", 0x12ab, 123.4, 123.4);
  181. }
  182.  
  183. #include <stdarg.h>
  184. #include <string.h>
  185.  
  186. int output(char *parmn, ...)
  187. {
  188.     va_list ap;
  189.     int count = strlen(parmn);
  190.     int j;
  191.  
  192.     va_start(ap, parmn);
  193.  
  194.     for (j = 1; j <= count; ++j) {
  195.         switch (*parmn) {
  196.  
  197. /* string */    case 'S': {
  198.             char *pc;
  199.  
  200.             pc = va_arg(ap, char *);
  201.             printf("%s", pc);
  202.             break;
  203.         }
  204.  
  205. /* decimal */    case 'D': {
  206.             int i;
  207.  
  208.             i = va_arg(ap, int);
  209.             printf("%d", i);
  210.             break;
  211.         }
  212.  
  213. /* character */    case 'C': {
  214.             int i;
  215.  
  216.             i = va_arg(ap, int);
  217.             printf("%c", i);
  218.             break;
  219.         }
  220.  
  221. /* hex digit */    case 'X': {
  222.             int i;
  223.  
  224.             i = va_arg(ap, int);
  225.             printf("%x", i);
  226.             break;
  227.         }
  228.  
  229. /* double */    case 'F': {
  230.             double d;
  231.  
  232.             d = va_arg(ap, double);
  233.             printf("%f", d);
  234.             break;
  235.         }
  236.  
  237. /* exponent */    case 'E': {
  238.             double d;
  239.  
  240.             d = va_arg(ap, double);
  241.             printf("%e", d);
  242.             break;
  243.         }
  244.  
  245.         default: {
  246.             putchar(*parmn);
  247.             break;
  248.         }
  249.         }
  250.         ++parmn;
  251.     }
  252.  
  253.     va_end(ap);
  254. }
  255.  
  256. abcd 123 A
  257. xyz 12ab 123.400000 1.234000e+002
  258.  
  259.