The Standard Library
Using the Library
The C89 standard library is divided into 15 parts, with each part described by a header. C99 has an additional nine headers.Most compilers come with more extensive library. so we can t count on them to be available with other compilers. These headers often provide functions that are specific on a particular computer or operating system (which explains why they're not standard). They may provide functions that allow more control over the screen and keyboard. Headers that support graphics or a window-based user interface are also common.
The standard headers consist primarily of function prototypes, type definitions, and macro definitions. If one of our files contains a call of a function declared in a header or uses one of the types or macros defined there, we'll need to include the header at the beginning of the file. When a file includes several standard headers, the order of #include directives doesn't matter. It's also legal to include a standard header more than once.
Restrictions on Names Used in the Library
Any file that includes a standard header must obey a couple of rules. First, it can't use the names of macros defined in that header for any other purpose. If a file includes
, for example, it
can't reuse NULL, since a macro by that name is already defined in
. Second, library names with file scope (typedef
names, in particular) can't be redefined at the file level. Thus, if a file
includes , it can't define size_t as a identifier
with file scope, since defines size_t to be a
Although these restrictions are pretty obvious, C has other restrictions that you might not expect:
Identifiers that begin with an underscore followed by an upper-case letter or a second underscore are reserved for use within the library: programs should never use names of this form for any purpose.
Identifiers that begin with an underscore are reserved for use as identifiers and tags with file scope. You should never use such a name for your own purposes unless it's declared inside a function.
Every identifier with external linkage in the standard library is reserved for use as an identifier with external linkage. In particular, the names of all standard library functions are reserved. Thus, even if a file doesn't include
, it shouldn't define an
external function named printf, since there's already a function with this
name in the library.
These rules apply to every file in a program, regardless of which headers the file includes. Although these rules aren't always enforced, failing to obey them can lead to a program that's not portable.
The rules listed above apply not just to names that are currently used in the library, but also to names that are set aside for future use. The complete description of which names are reserved is rather lengthy: you'll find it in the C standard under "future library directions." As an example, C reserves identifiers that begin with str followed by a lower-case letter, so that functions with such names can be added to the
Functions Hidden by Macros
It's common for C programmers to replace small functions by parameterized macros. This practice occurs even in the standard library. The C standard allows headers to define macros that have the same names as library functions, but protects the programmer by requiring that a true function be available as well. As a result, it's not unusual for a library header to declare a function and define a macro with the same name.
We've already seen an example of a macro duplicating a library function, getchar is a library function declared in the
header. It has the following
#define getchar() getc(stdin)
By default, a call of getchar will be treated as a macro invocation (since macro names are replaced during preprocessing).
Most of the time, we're happy using a macro instead of a true function, because it will probably make our program run faster. Occasionally, though, we want a genuine function, perhaps to minimize the size of the executable code.
C89 Library Overview
We'll now take a quick look at the headers in the C89 standard library. This section can serve as a "road map" to help you determine which part of the library you need. Each header is described in detail.
Contains only the assert macro, which allows us to insert self-checks into a program. If any check fails, the program terminates.
< ctype.h > Character Handling
cctype. h> header >
Provides functions for classifying characters and for converting letters from lower to upper case or vice versa.
< errno.h> Errors
Provides macros that describe the characteristics of floating types, including their range and accuracy.
Provides macros that describe the characteristics of integer types (including character types), including their maximum and minimum values.
Provides functions to help a program adapt its behavior to a country or other geographic region. Locale-specific behavior includes the way numbers are printed (such as the character used as the decimal point), the format of monetary values (the currency symbol, for example), the character set, and the appearance of the date and time.
Provides common mathematical functions, including trigonometric, hyperbolic, exponential, logarithmic, power, nearest integer, absolute value, and remainder functions.
Provides the set jmp and longjmp functions, set jmp "marks" a place in a program: longjmp can then be used to return to that place later. These functions make it possible to jump from one function into another, still-active function, bypassing the normal function-return mechanism, set jmp and longjmp are used primarily for handling serious problems that arise during program execution.
< signal.h > Signal Handling
Provides functions that deal with exceptional conditions (signals), including interrupts and run-time errors. The signal function installs a function to be called if a given signal should occur later. The raise function causes a signal to occur.
< stdarg. h> Variable Arguments
Provides tools for writing functions that, like printf and scanf, can have a variable number of arguments.
< stdde f. h> Common Definitions
Provides definitions of frequently used types and macros.
Provides a large assortment of input/output functions, including operations on both sequential and random-access files.
< stdlib.h> General Utilities
A "catchall" header for functions that don't fit into any of the other headers. The functions in this header can convert strings to numbers, generate pseudo-random numbers, perform memory management tasks, communicate with the operating system, do searching and sorting, and perform conversions between multibyte characters and wide characters.
Provides functions thai perform string operations, including copying, concatenation, comparison, and searching, as well as functions that operate on arbitrary blocks of memory.
< time. h> Date and Time
Provides functions for determining the time (and date), manipulating times, and formatting times for display.
< complex.h> Complex Arithmetic
Defines the complex and I macros, which are useful when working with complex numbers. Also provides functions for performing mathematical operations on complex numbers.
< fenv. h> Floating-Point Environment
Provides access to floating-point status flags and control modes. For example, a program might test a flag to see if overflow occurred during a floating-point operation or set a control mode to specify how rounding should be done.
Defines macros that can be used in format strings for input/output of the integer types declared in
. Also provides functions for working with greatest-width
Defines macros that represent certain operators .These macros are useful for writing programs in an environment where these characters might not be pan of the local character set.
Defines the bool. true, and false macros, as well as a macro that can be used to test whether these macros have been defined.
Declares integer types with specified widths and defines related macros (such as macros that specify the maximum and minimum values of each type). Also defines parameterized macros that construct integer constants with specific types.
< tgmath.h > Type-Generic Math
In C99. there are multiple versions of many math functions in the
and headers. The
"type-generic" macros in can detect the types of the
arguments passed to them and substitute a call of the appropriate
Provides functions for wide-character input/output and wide string manipulation.
The wide-character version of
Provides functions for classifying and changing the case of wide characters.