Libraries and "the One Right Way"

Any fool can turn out a book on the C runtime library--those functions such as printf(), strlen(), sqrt(), and setjmp()--and a quick trip to your local bookstore will reveal that many fools have. All it takes is the ability to copy, mistakes and all, the vendor's original documentation, and then serve up the resulting pointlessness as The Microsoft C Bible, The Complete Guide to Turbo C, or The Turbo C++ Programmer's Reference.

Our first book this month is a book on the C standard library that, wonder of wonders, has things you won't find in the manuals that came with your compiler. In fact, P.J. Plauger's The Standard C Library aims not so much to show how to use the C standard library, but to show how it is implemented. This is an incredible book! Instead of wasting paper just showing you how to call printf(), Plauger (who chaired the Library subcommittee of the ANSI C committee) shows you how to write printf--and scanf, malloc, sqrt, and every other function in the library approved by the ANSI and ISO standards for C.

Besides presenting about 9,000 lines of C code for a complete portable C runtime library, Plauger explains it all pretty much line-by-line, with special emphasis given to international considerations (multibyte character sets are given extensive coverage here), portability, testing, and handling of errors and oddities. For example, the chapter on stresses the way in which even a seemingly trivial operation such as fabs (floating-point absolute value) is complicated and made nontrivial by the need to handle screwball values such as infinity and NaN (Not a Number). While authors of computer books frequently engage in "exercise left for the reader" cop-outs, Plauger seems to delight in tackling such nasties.

Certainly there are places where Plauger decides not to deal with an issue. The chapters explaining machine-specific facilities such as and are, in the interests of portability, somewhat vague. The implementation of realloc() does not try to expand a block in place. But Plauger is generally quite explicit about such limitations.

Some of the material in The Standard C Library has appeared in Plauger's monthly "Standard C" column in the C User's Journal. The book contains one chapter for each of the 15 .h files that make up the ANSI and ISO standard C library. Each chapter contains the following sections:

• A "Background" section that includes useful historical information (for example, the chapter on discusses the evolution of the device-independent input/output model)
• "What the C Standard Says" (a reprint in very tiny type of the relevant pages from the ISO 9899:1990 standard)
• A section on using the facility
• A meaty section on implementing the facility (for example, implementing gets 50 pages)
• A section on testing--yes, testing--the facility
• An extremely thoughtful bibliography (for example, the chapter refers the reader to the 1976 PDP-11 manual, because PDP-11 traps and interrupts inspired the signals defined for C)
• Exercises (some of the ones for look really difficult!)

 // stack.h
 template class stack
 {
 T *V, *p;
 int sz;
 public:

 // all the following functions are inline
 stack(int s) { v = p = new T[sz = s]; }
 -stack() { delete[] v; }
 void push (T a) { *p++ = a; }
 T pop() { return *--p; }
 int size() const { return p-v; }
 }

 #include 
 #include "stack.h"

 main()
 {
 stack si(100); // stack of 100 ints
 stack sc(100); // stack of 100 chars

 for (int i=0; i10; i++)
 {
 si.push(i);
 sc.push(i);
 }
 while (si.size()) // pop everything and
 cout  si.pop()  ' ' ; // display it
 cout  '\n' ;
 }

 mov bx, word ptr [si.p]
 mov ax, word ptr [i]
 mov word ptr [bx], ax ; *p = i
 add word ptr [si.p], 2 ; p += sizeof(int)