"The C Programming Language", 2nd edition, Kernighan and Ritchie

目      录
译者序
序
第1版序
前言
第1章   基本概念 
1.1   入门 
1.2   变量与算术表达式 
1.3   for语句 
1.4   符号常量 
1.5   字符输入输出 
1.5.1   文件复制 
1.5.2   字符计数 
1.5.3   行计数 
1.5.4   单词计数 
1.6   数组 
1.7   函数 
1.8   变元—按值调用 
1.9   字符数组 
1.10   外部变量与作用域 
第2章   类型、运算符与表达式 
2.1   变量名 
2.2   数据类型与大小 
2.3   常量 
2.4   说明 
2.5   算术运算符 
2.6   关系运算符与逻辑运算符  
2.7   类型转换 
2.8   加一与减一运算符 
2.9   按位运算符 
2.10   赋值运算符与赋值表达式 
2.11   条件表达式 
2.12   运算符优先级与表达式求值次序 
第3章   控制流 
3.1   语句与分程序 
3.2    if-else语句 
3.3   else-if语句 
3.4   switch语句 
3.5   while与for循环语句 
3.6   do-while循环语句 
3.7   break语句与continue语句 
3.8   goto语句与标号 
第4章   函数与程序结构 
4.1   函数的基本知识 
4.2   返回非整数值的函数 
4.3   外部变量 
4.4   作用域规则 
4.5   头文件 
4.6   静态变量 
4.7   寄存器变量 
4.8   分程序结构 
4.9   初始化 
4.10   递归 
4.11   C预处理程序 
4.11.1   文件包含 
4.11.2   宏替换 
4.11.3   条件包含 
第5章   指针与数组 
5.1   指针与地址 
5.2   指针与函数变元 
5.3   指针与数组 
5.4   地址算术运算 
5.5   字符指针与函数 
5.6   指针数组与指向指针的指针 
5.7   多维数组 
5.8   指针数组的初始化 
5.9   指针与多维数组 
5.10   命令行变元 
5.11   指向函数的指针 
5.12   复杂说明 
第6章   结构 
6.1   结构的基本知识 
6.2   结构与函数 
6.3   结构数组 
6.4   结构指针 
6.5   自引用结构 
6.6   查找表 
6.7   类型定义 
6.8   联合 
6.9   位字段 
第7章   输入与输出 
7.1   标准输入输出 
7.2   格式输出—printf函数 
7.3   变长变元表 
7.4   格式输入—scanf函数 
7.5   文件访问 
7.6   错误处理—stderr和exit函数 
7.7   行输入输出 
7.8   其他函数 
7.8.1   字符串处理函数 
7.8.2   字符类测试和转换函数 
7.8.3   ungetc函数 
7.8.4   命令执行函数 
7.8.5   存储管理函数 
7.8.6   数学函数 
7.8.7   随机数发生器函数 
第8章   UNIX系统界面 
8.1   文件描述符 
8.2   低级I/O—read和write系统调用 
8.3   open、creat、close和unlink系统调用 
8.4   随机访问—lseek系统调用 
8.5   实例—fopen和getc函数的一种实现
方法 
8.6   实例—目录显示 
8.7   实例—存储分配程序 
附录A   参考手册 
A.1   引言 
A.2   词法规则 
A.3   语法符号 
A.4   标识符的含义 
A.5   对象和左值 
A.6   转换 
A.7   表达式 
A.8   说明 
A.9   语句 
A.10   外部说明 
A.11   作用域与连接 
A.12      预处理 
A.13   语法 
附录B   标准库 
B.1   输入与输出：<stdio.h> 
B.2   字符类测试：<ctype.h> 
B.3   字符串函数：<string.h> 
B.4   数学函数：<math.h> 
B.5   实用函数：<stdlib.h> 
B.6   诊断：<assert.h> 
B.7   变量变元表：<stdarg.h> 
B.8   非局部跳转：<setjmp.h> 
B.9   信号处理：<signal.h> 
B.10   日期与时间函数：<time.h> 
B.11   由实现定义的限制：<limits.h>和
<float.h> 
附录C   变更小结 

1. getchar() and putchar()
3. #include <stdio.h>
4. /* 用于将输入复制到输出的程序；第2个版本*/
5. main ( )
6. {
7. int c;
8. while ( (c = getchar ( ) ) != EOF )//End Of File，文件结束< stdio.h>库定义的整数
9. putchar ( c );
10. }
11. 在这一程序中，w h i l e循环语句先读一个字符并将其赋给c，然后测试该字符是否为文件结束标记。如果该字符不是文件结束标记，那么就执行w h i l e语句体，把该字符打印出来。再重复执行该w h i l e语句。当最后到达输入结束位置时， w h i l e循环语句终止执行，从而整个m a i n程序执行结束。之所以不把c说明成c h a r类型，是因为c必须大到除了能存储任何可能的字符外还要能存储文件结束符E O F。因此，把c说明成i n t类型的。

1.5.1 文件复制

Verify that the expression getchar() != EOF is 0 or 1.

1. #include <stdio.h>
3. int main(void)
4. {
5.   printf("Press a key. ENTER would be nice :-)/n/n");
6.   printf("The expression getchar() != EOF evaluates to %d/n", getchar() != EOF);
7.   return 0;
8. }

Write a program to print the value of EOF .

1. #include <stdio.h>
3. int main(void)
4. {
5.   printf("The value of EOF is %d/n/n", EOF);
6.   
7.   return 0;
8. }

1.5.2 字符计数

1. #include <stdio.h>
2. /* 统计输入的字符数； 第2个版本*/
3. main ( )
4. {
5. double nc;
6. for ( nc = 0; getchar ( ) != EOF; ++nc )
7. ;
8. printf("%.0f/n", nc);
9. }

1. #include <stdio.h>
2. /* 统计输入的行数*/
3. main ( )
4. {
5. long c, nl;
6. nl = 0;
7. while ( (c = getchar ( ) ) != EOF )
8. if ( c =='/n' )
9. ++nl;
10. printf("%d/n", nl);
11. }

编写一个用于统计空格、制表符与换行符个数的程序

Write a program to count blanks, tabs, and newlines

1. #include <stdio.h>
3. int main(void)
4. {
5.   int blanks, tabs, newlines;
6.   int c;
7.   int done = 0;
8.   int lastchar = 0;
10.   blanks = 0;
11.   tabs = 0;
12.   newlines = 0;
14.   while(done == 0)
15.   {
16.     c = getchar();
18.     if(c == ' ')
19.       ++blanks;
21.     if(c == '/t')
22.       ++tabs;
24.     if(c == '/n')
25.       ++newlines;
27.     if(c == EOF)
28.     {
29.       if(lastchar != '/n')
30.       {
31.         ++newlines; /* this is a bit of a semantic stretch, but it copes
32.                      * with implementations where a text file might not
33.                      * end with a newline. Thanks to Jim Stad for pointing
34.                      * this out.
35.                      */
36.       }
37.       done = 1;
38.     }
39.     lastchar = c;
40.   }
42.   printf("Blanks: %d/nTabs: %d/nLines: %d/n", blanks, tabs, newlines);
43.   return 0;
44. }

编写一个程序，把它的输入复制到输出，并在此过程中将相连的多个空格用一个
空格代替。

Write a program to copy its input to its output, replacing each string of one or more blanks by a single blan

1. #include <stdio.h>
3. int main(void)
4. {
5.   int c;
6.   int inspace;
8.   inspace = 0;
9.   while((c = getchar()) != EOF)
10.   {
11.     if(c == ' ')
12.     {
13.       if(inspace == 0)
14.       {
15.         inspace = 1;
16.         putchar(c);
17.       }
18.     }
20.     /* We haven't met 'else' yet, so we have to be a little clumsy */
21.     if(c != ' ')
22.     {
23.       inspace = 0;
24.       putchar(c);
25.     }
26.   }
28.   return 0;
29. }
33. Chris Sidi writes: "instead of having an "inspace" boolean, you can keep track of the previous character and see if both the current character and previous character are spaces:" 
38. #include <stdio.h>
40. /* count lines in input */
41. int
42. main()
43. {
44.         int c, pc; /* c = character, pc = previous character */
46.         /* set pc to a value that wouldn't match any character, in case
47.         this program is ever modified to get rid of multiples of other
48.         characters */
50.         pc = EOF;
52.         while ((c = getchar()) != EOF) {
53.                 if (c == ' ')
54.                         if (pc != ' ')   /* or if (pc != c) */ 
55.                                 putchar(c);
57.                 /* We haven't met 'else' yet, so we have to be a little clumsy */
58.                 if (c != ' ')
59.                         putchar(c);
60.                 pc = c;
61.         }
63.         return 0;
64. }
70. Stig writes: "I am hiding behind the fact that break is mentioned in the introduction"! 
73. #include <stdio.h>
75. int main(void)
76. {
77.         int c;
78.         while ((c = getchar()) != EOF) {
79.                 if (c == ' ') {
80.                        putchar(c);
81.                        while((c = getchar()) == ' ' && c != EOF)
82.                                ;
83.                }
84.                if (c == EOF)
85.                        break; /* the break keyword is mentioned
86.                                * in the introduction... 
87.                                * */
89.                putchar(c);
90.         }
91.         return 0;
92. } 

编写一个程序，把它的输入复制到输出，并在此过程中把制表符换成/ t、把回退
符换成/ b、把反斜杠换成/ /。这样可以使得制表符与回退符能以无歧义的方式可见。

Write a program to copy its input to its output, replacing each tab by /t , each backspace by /b , and each backslash by // . This makes tabs and backspaces visible in an unambiguous way. 

 

1. Category 0 
2. Gregory Pietsch pointed out that my solution was actually Category 1. He was quite right. Better still, he was kind enough to submit a Category 0 solution himself. Here it is: 
5. /* Gregory Pietsch <[email protected]> */
7. /*
8.  * Here's my attempt at a Category 0 version of 1-10.
9.  *
10.  * Gregory Pietsch
11.  */
13. #include <stdio.h>
15. int main()
16. {
17.     int c, d;
19.     while ( (c=getchar()) != EOF) {
20.         d = 0;
21.         if (c == '//') {
22.             putchar('//');
23.             putchar('//');
24.             d = 1;
25.         }
26.         if (c == '/t') {
27.             putchar('//');
28.             putchar('t');
29.             d = 1;
30.         }
31.         if (c == '/b') {
32.             putchar('//');
33.             putchar('b');
34.             d = 1;
35.         }
36.         if (d == 0)
37.             putchar(c);        
38.     }
39.     return 0;
40. }
47. Category 1 
50. This solution, which I wrote myself, is the sadly discredited Cat 0 answer which has found a new lease of life in Category 1. 
53. #include <stdio.h>
55. #define ESC_CHAR '//'
57. int main(void)
58. {
59.   int c;
61.   while((c = getchar()) != EOF)
62.   {
63.     switch(c)
64.     {
65.       case '/b':
66.         /* The OS on which I tested this (NT) intercepts /b characters. */
67.         putchar(ESC_CHAR);
68.         putchar('b');
69.         break;
70.       case '/t':
71.         putchar(ESC_CHAR);
72.         putchar('t');
73.         break;
74.       case ESC_CHAR:
75.         putchar(ESC_CHAR);
76.         putchar(ESC_CHAR);
77.         break;
78.       default:
79.         putchar(c);
80.         break;
81.     }
82.   }
83.   return 0;
84. } 

 1.5.4 单词计数

 

1. #include <stdio.h>
2. #define IN 1 /* 在单词内*/
3. #define OUT 0 /* 在单词外*/
4. /* 统计输入的行数、单词数与字符数*/
5. main ( )
6. {
7. int c, nl, nw, nc, state;
8. state = OUT;
9. nl = nw = nc = 0;
10. while ( (c = getchar ( ) ) != EOF ) {
11. ++nc;
12. if ( c =='/n' )
13. ++nl;
14. if ( c == ' ' ||c == '/n' || c == '/t' )
15. state = OUT;
16. else if ( state == OUT ) {
17. state = IN;
18. ++nw;
19. }
20. }
21. printf("%d %d %d/n", nl, nw, nc);
22. }

你准备怎样测试单词计数程序？如果程序中出现任何错误，那么什么样的输入最
有利于发现这些错误？

How would you test the word count program? What kinds of input are most likely to uncover bugs if there are any?

1. It sounds like they are really trying to get the programmers to learn how to do a unit test. I would submit the following: 
3. 0. input file contains zero words 
4. 1. input file contains 1 enormous word without any newlines 
5. 2. input file contains all white space without newlines 
6. 3. input file contains 66000 newlines 
7. 4. input file contains word/{huge sequence of whitespace of different kinds}/word 
8. 5. input file contains 66000 single letter words, 66 to the line 
9. 6. input file contains 66000 words without any newlines 
10. 7. input file is /usr/dict contents (or equivalent) 
11. 8. input file is full collection of moby words 
12. 9. input file is binary (e.g. its own executable) 
13. 10. input file is /dev/nul (or equivalent) 
15. 66000 is chosen to check for integral overflow on small integer machines. 
21. Dann suggests a followup exercise 1-11a: write a program to generate inputs (0,1,2,3,4,5,6) 
25. I guess it was inevitable that I'd receive a solution for this followup exercise! Here is Gregory Pietsch's program to generate Dann's suggested inputs: 
28. #include <assert.h>
29. #include <stdio.h>
31. int main(void)
32. {
33.     FILE *f;
34.     unsigned long i;
35.     static char *ws = " /f/t/v";
36.     static char *al = "abcdefghijklmnopqrstuvwxyz";
37.     static char *i5 = "a b c d e f g h i j k l m "
38.                       "n o p q r s t u v w x y z "
39.                       "a b c d e f g h i j k l m "
40.                       "n o p q r s t u v w x y z "
41.                       "a b c d e f g h i j k l m "
42.                       "n/n";
44.     /* Generate the following: */
45.     /* 0. input file contains zero words */
46.     f = fopen("test0", "w");
47.     assert(f != NULL);
48.     fclose(f);
50.     /* 1. input file contains 1 enormous word without any newlines */
51.     f = fopen("test1", "w");
52.     assert(f != NULL);
53.     for (i = 0; i < ((66000ul / 26) + 1); i++)
54.         fputs(al, f);
55.     fclose(f);
57.     /* 2. input file contains all white space without newlines */
58.     f = fopen("test2", "w");
59.     assert(f != NULL);
60.     for (i = 0; i < ((66000ul / 4) + 1); i++)
61.         fputs(ws, f);
62.     fclose(f);
64.     /* 3. input file contains 66000 newlines */
65.     f = fopen("test3", "w");
66.     assert(f != NULL);
67.     for (i = 0; i < 66000; i++)
68.         fputc('/n', f);
69.     fclose(f);
71.     /* 4. input file contains word/ 
72.      *    {huge sequence of whitespace of different kinds}
73.      *    /word 
74.      */
75.     f = fopen("test4", "w");
76.     assert(f != NULL);
77.     fputs("word", f);
78.     for (i = 0; i < ((66000ul / 26) + 1); i++)
79.         fputs(ws, f);
80.     fputs("word", f);
81.     fclose(f);
83.     /* 5. input file contains 66000 single letter words,
84.      *    66 to the line 
85.      */
86.     f = fopen("test5", "w");
87.     assert(f != NULL);
88.     for (i = 0; i < 1000; i++)
89.         fputs(i5, f);
90.     fclose(f);
92.     /* 6. input file contains 66000 words without any newlines */
93.     f = fopen("test6", "w");
94.     assert(f != NULL);
95.     for (i = 0; i < 66000; i++)
96.         fputs("word ", f);
97.     fclose(f);
99.     return 0;
100. }

编写一个程序，以每行一个单词的形式打印输入。

Write a program that prints its input one word per line.

 

1. #include <stdio.h>
2. int main(void)
3. {
4.   int c;
5.   int inspace;
7.   inspace = 0;
8.   while((c = getchar()) != EOF)
9.   {
10.     if(c == ' ' || c == '/t' || c == '/n')
11.     {
12.       if(inspace == 0)
13.       {
14.         inspace = 1;
15.         putchar('/n');
16.       }
17.       /* else, don't print anything */
18.     }
19.     else
20.     {
21.       inspace = 0;
22.       putchar(c);
23.     }
24.   }
25.   return 0;
26. }

1.6 数组

1. #include <stdio.h>
2. /* 统计各个数字、空白字符及其他字符分别出现的次数*/
3. main ( )
4. {
5. int c, i, nwhite, nother;
6. int ndigit[10];
7. nwhite = nother = 0;
8. for ( i =0; i < 10; ++i )
9. ndigit[i] = 0;
10. while ( ( c = getchar() ) != EOF )
11. if ( c >= '0' && c <= '9' )
12. ++ndigit[c - '0'];
13. else if ( c == ' ' ||c == '/n' || c == '/t' )
14. ++nwhite;
15. else
16. ++nother;
17. printf( "digits =" );
18. for ( i =0; i < 10; ++i )
19. printf( " %d", ndigit[i] );
20. printf( ", white space = %d, other = %d", nwhite, nother);
21. }
22. 当把程序自身作为输入时，输出为：
    digits = 9 3 0 0 0 0 0 0 0 1, white space = 123, other = 345

练习1-13 编写一个程序，打印其输入的文件中单词长度的直方图。横条的直方图比较容易
绘制，竖条直方图则要困难些。

Write a program to print a histogram of the lengths of words in its input. It is easy to draw the histogram with the bars horizontal; a vertical orientation is more challenging.

 

1. #include <stdio.h>
3. #define MAXWORDLEN 10
5. int main(void)
6. {
7.   int c;
8.   int inspace = 0;
9.   long lengtharr[MAXWORDLEN + 1];
10.   int wordlen = 0;
12.   int firstletter = 1;
13.   long thisval = 0;
14.   long maxval = 0;
15.   int thisidx = 0;
16.   int done = 0;
18.   for(thisidx = 0; thisidx <= MAXWORDLEN; thisidx++)
19.   {
20.     lengtharr[thisidx] = 0;
21.   }
23.   while(done == 0)
24.   {
25.     c = getchar();
27.     if(c == ' ' || c == '/t' || c == '/n' || c == EOF)
28.     {
29.       if(inspace == 0)
30.       {
31.         firstletter = 0;
32.         inspace = 1;
34.         if(wordlen <= MAXWORDLEN)
35.         {
36.           if(wordlen > 0)
37.           {
38.             thisval = ++lengtharr[wordlen - 1];
39.             if(thisval > maxval)
40.             {
41.               maxval = thisval;
42.             }
43.           }
44.         }
45.         else
46.         {
47.           thisval = ++lengtharr[MAXWORDLEN];
48.           if(thisval > maxval)
49.           {
50.             maxval = thisval;
51.           }
52.         }
53.       }
54.       if(c == EOF)
55.       {
56.         done = 1;
57.       }
58.     }
59.     else
60.     {
61.       if(inspace == 1 || firstletter == 1)
62.       {
63.         wordlen = 0;
64.         firstletter = 0;
65.         inspace = 0;
66.       }
67.       ++wordlen;
68.     }
69.   }
71.   for(thisval = maxval; thisval > 0; thisval--)
72.   {
73.     printf("%4d  | ", thisval);
74.     for(thisidx = 0; thisidx <= MAXWORDLEN; thisidx++)
75.     {
76.       if(lengtharr[thisidx] >= thisval)
77.       {
78.         printf("*  ");
79.       }
80.       else
81.       {
82.         printf("   ");
83.       }
84.     }
85.     printf("/n");
86.   }
87.   printf("      +");
88.   for(thisidx = 0; thisidx <= MAXWORDLEN; thisidx++)
89.   {
90.     printf("---");
91.   }
92.   printf("/n       ");
93.   for(thisidx = 0; thisidx < MAXWORDLEN; thisidx++)
94.   {
95.     printf("%2d ", thisidx + 1);
96.   }
97.   printf(">%d/n", MAXWORDLEN);
99.   return 0;
100. }
105. Here's the output of the program when given its own source as input: 
108.  113  | *                                
109.  112  | *                                
110.  111  | *                                
111.  110  | *                                
112.  109  | *                                
113.  108  | *                                
114.  107  | *                                
115.  106  | *                                
116.  105  | *                                
117.  104  | *                                
118.  103  | *                                
119.  102  | *                                
120.  101  | *                                
121.  100  | *                                
122.   99  | *                                
123.   98  | *                                
124.   97  | *                                
125.   96  | *                                
126.   95  | *                                
127.   94  | *  *                             
128.   93  | *  *                             
129.   92  | *  *                             
130.   91  | *  *                             
131.   90  | *  *                             
132.   89  | *  *                             
133.   88  | *  *                             
134.   87  | *  *                             
135.   86  | *  *                             
136.   85  | *  *                             
137.   84  | *  *                             
138.   83  | *  *                             
139.   82  | *  *                             
140.   81  | *  *                             
141.   80  | *  *                             
142.   79  | *  *                             
143.   78  | *  *                             
144.   77  | *  *                             
145.   76  | *  *                             
146.   75  | *  *                             
147.   74  | *  *                             
148.   73  | *  *                             
149.   72  | *  *                             
150.   71  | *  *                             
151.   70  | *  *                             
152.   69  | *  *                             
153.   68  | *  *                             
154.   67  | *  *                             
155.   66  | *  *                             
156.   65  | *  *                             
157.   64  | *  *                             
158.   63  | *  *  *                          
159.   62  | *  *  *                          
160.   61  | *  *  *                          
161.   60  | *  *  *                          
162.   59  | *  *  *                          
163.   58  | *  *  *                          
164.   57  | *  *  *                          
165.   56  | *  *  *                          
166.   55  | *  *  *                          
167.   54  | *  *  *                          
168.   53  | *  *  *                          
169.   52  | *  *  *  *                       
170.   51  | *  *  *  *                       
171.   50  | *  *  *  *                       
172.   49  | *  *  *  *                       
173.   48  | *  *  *  *                       
174.   47  | *  *  *  *                       
175.   46  | *  *  *  *                       
176.   45  | *  *  *  *                       
177.   44  | *  *  *  *                       
178.   43  | *  *  *  *        *              
179.   42  | *  *  *  *        *              
180.   41  | *  *  *  *        *              
181.   40  | *  *  *  *        *              
182.   39  | *  *  *  *        *              
183.   38  | *  *  *  *        *              
184.   37  | *  *  *  *        *              
185.   36  | *  *  *  *        *              
186.   35  | *  *  *  *        *              
187.   34  | *  *  *  *        *              
188.   33  | *  *  *  *        *              
189.   32  | *  *  *  *        *              
190.   31  | *  *  *  *        *              
191.   30  | *  *  *  *        *           *  
192.   29  | *  *  *  *        *           *  
193.   28  | *  *  *  *  *     *           *  
194.   27  | *  *  *  *  *     *           *  
195.   26  | *  *  *  *  *     *           *  
196.   25  | *  *  *  *  *  *  *           *  
197.   24  | *  *  *  *  *  *  *           *  
198.   23  | *  *  *  *  *  *  *           *  
199.   22  | *  *  *  *  *  *  *        *  *  
200.   21  | *  *  *  *  *  *  *        *  *  
201.   20  | *  *  *  *  *  *  *        *  *  
202.   19  | *  *  *  *  *  *  *        *  *  
203.   18  | *  *  *  *  *  *  *        *  *  
204.   17  | *  *  *  *  *  *  *        *  *  
205.   16  | *  *  *  *  *  *  *        *  *  
206.   15  | *  *  *  *  *  *  *        *  *  
207.   14  | *  *  *  *  *  *  *  *     *  *  
208.   13  | *  *  *  *  *  *  *  *     *  *  
209.   12  | *  *  *  *  *  *  *  *     *  *  
210.   11  | *  *  *  *  *  *  *  *     *  *  
211.   10  | *  *  *  *  *  *  *  *     *  *  
212.    9  | *  *  *  *  *  *  *  *  *  *  *  
213.    8  | *  *  *  *  *  *  *  *  *  *  *  
214.    7  | *  *  *  *  *  *  *  *  *  *  *  
215.    6  | *  *  *  *  *  *  *  *  *  *  *  
216.    5  | *  *  *  *  *  *  *  *  *  *  *  
217.    4  | *  *  *  *  *  *  *  *  *  *  *  
218.    3  | *  *  *  *  *  *  *  *  *  *  *  
219.    2  | *  *  *  *  *  *  *  *  *  *  *  
220.    1  | *  *  *  *  *  *  *  *  *  *  *  
221.       +---------------------------------
222.         1  2  3  4  5  6  7  8  9 10 >10

 

练习1-14 编写一个程序，打印其输入的文件中各个字符出现频率的直方图。

Write a program to print a histogram of the frequencies of different characters in its input.

1. #include <stdio.h>
3. /* NUM_CHARS should really be CHAR_MAX but K&R haven't covered that at this stage in the book */
4. #define NUM_CHARS 256
6. int main(void)
7. {
8.   int c;
9.   long freqarr[NUM_CHARS + 1];
11.   long thisval = 0;
12.   long maxval = 0;
13.   int thisidx = 0;
15.   for(thisidx = 0; thisidx <= NUM_CHARS; thisidx++)
16.   {
17.     freqarr[thisidx] = 0;
18.   }
20.   while((c = getchar()) != EOF)
21.   {
22.     if(c < NUM_CHARS)
23.     {
24.       thisval = ++freqarr[c];
25.       if(thisval > maxval)
26.       {
27.         maxval = thisval;
28.       }
29.     }
30.     else
31.     {
32.       thisval = ++freqarr[NUM_CHARS];
33.       if(thisval > maxval)
34.       {
35.         maxval = thisval;
36.       }
37.     }
38.   }
40.   for(thisval = maxval; thisval > 0; thisval--)
41.   {
42.     printf("%4d  |", thisval);
43.     for(thisidx = 0; thisidx <= NUM_CHARS; thisidx++)
44.     {
45.       if(freqarr[thisidx] >= thisval)
46.       {
47.         printf("*");
48.       }
49.       else if(freqarr[thisidx] > 0)
50.       {
51.         printf(" ");
52.       }
53.     }
54.     printf("/n");
55.   }
56.   printf("      +");
57.   for(thisidx = 0; thisidx <= NUM_CHARS; thisidx++)
58.   {
59.     if(freqarr[thisidx] > 0)
60.     {
61.       printf("-");
62.     }
63.   }
64.   printf("/n       ");
65.   for(thisidx = 0; thisidx < NUM_CHARS; thisidx++)
66.   {
67.     if(freqarr[thisidx] > 0)
68.     {
69.       printf("%d", thisidx / 100);
70.     }
71.   }
72.   printf("/n       ");
73.   for(thisidx = 0; thisidx < NUM_CHARS; thisidx++)
74.   {
75.     if(freqarr[thisidx] > 0)
76.     {
77.       printf("%d", (thisidx - (100 * (thisidx / 100))) / 10 );
78.     }
79.   }
80.   printf("/n       ");
81.   for(thisidx = 0; thisidx < NUM_CHARS; thisidx++)
82.   {
83.     if(freqarr[thisidx] > 0)
84.     {
85.       printf("%d", thisidx - (10 * (thisidx / 10)));
86.     }
87.   }
88.   if(freqarr[NUM_CHARS] > 0)
89.   {
90.     printf(">%d/n", NUM_CHARS);
91.   }
93.   printf("/n");
95.   return 0;
96. }
101. Here's the output of the program when given its own source as input: 
104.  474  | *                                                                    
105.  473  | *                                                                    
106.  472  | *                                                                    
107.  471  | *                                                                    
108.  470  | *                                                                    
109.  469  | *                                                                    
110.  468  | *                                                                    
111.  467  | *                                                                    
112.  466  | *                                                                    
113.  465  | *                                                                    
114.  464  | *                                                                    
115.  463  | *                                                                    
116.  462  | *                                                                    
117.  461  | *                                                                    
118.  460  | *                                                                    
119.  459  | *                                                                    
120.  458  | *                                                                    
121.  457  | *                                                                    
122.  456  | *                                                                    
123.  455  | *                                                                    
124.  454  | *                                                                    
125.  453  | *                                                                    
126.  452  | *                                                                    
127.  451  | *                                                                    
128.  450  | *                                                                    
129.  449  | *                                                                    
130.  448  | *                                                                    
131.  447  | *                                                                    
132.  446  | *                                                                    
133.  445  | *                                                                    
134.  444  | *                                                                    
135.  443  | *                                                                    
136.  442  | *                                                                    
137.  441  | *                                                                    
138.  440  | *                                                                    
139.  439  | *                                                                    
140.  438  | *                                                                    
141.  437  | *                                                                    
142.  436  | *                                                                    
143.  435  | *                                                                    
144.  434  | *                                                                    
145.  433  | *                                                                    
146.  432  | *                                                                    
147.  431  | *                                                                    
148.  430  | *                                                                    
149.  429  | *                                                                    
150.  428  | *                                                                    
151.  427  | *                                                                    
152.  426  | *                                                                    
153.  425  | *                                                                    
154.  424  | *                                                                    
155.  423  | *                                                                    
156.  422  | *                                                                    
157.  421  | *                                                                    
158.  420  | *                                                                    
159.  419  | *                                                                    
160.  418  | *                                                                    
161.  417  | *                                                                    
162.  416  | *                                                                    
163.  415  | *                                                                    
164.  414  | *                                                                    
165.  413  | *                                                                    
166.  412  | *                                                                    
167.  411  | *                                                                    
168.  410  | *                                                                    
169.  409  | *                                                                    
170.  408  | *                                                                    
171.  407  | *                                                                    
172.  406  | *                                                                    
173.  405  | *                                                                    
174.  404  | *                                                                    
175.  403  | *                                                                    
176.  402  | *                                                                    
177.  401  | *                                                                    
178.  400  | *                                                                    
179.  399  | *                                                                    
180.  398  | *                                                                    
181.  397  | *                                                                    
182.  396  | *                                                                    </