Library features

C99 supports additional macros, types, and functions in the standard header <math.h> that are not found in the corresponding C90 standard header.

New macros found in C99 that are not found in C90 include:

INFINITY // positive infinity
NAN      // IEEE not‑a‑number

New generic function macros found in C99 that are not found in C90 include:

#define isinf(x) // non‑zero only if x is positive or negative infinity
#define isnan(x) // non‑zero only if x is NaN
#define isless(x, y) // 1 only if x < y and x and y are not NaN, and 0 otherwise
#define isunordered(x, y) // 1 only if either x or y is NaN, and 0 otherwise

New mathematical functions found in C99 that are not found in C90 include:

double acosh(double x); // hyperbolic arccosine of x
double asinh(double x); // hyperbolic arcsine of x
double atanh(double x); // hyperbolic arctangent of x
double erf(double x); // returns the error function of x
double round(double x); // returns x rounded to the nearest integer
double tgamma(double x); // returns the gamma function of x

C99 supports the new mathematical functions for all real floating‑point types.

Single precision versions of all existing <math.h> functions are also supported.

C99 introduces the native type _Bool. The associated standard header <stdbool.h> introduces the macros bool, true and false for Boolean tests. For example:

#include <stdbool.h>

bool foo(FILE *str)
{
    bool err = false;

    ...
    if (!fflush(str))
    {
        err = true;
    }
    ...
    return err;
}

In C90, the long data type can serve both as the largest integral type, and as a 32‑bit container. C99 removes this ambiguity through the new standard library header files <inttypes.h> and <stdint.h>.

The header file <stdint.h> introduces the new types:

The header file <inttypes.h> provides library functions for manipulating values of type intmax_t, including:

intmax_t imaxabs(intmax_t x); // absolute value of x
imaxdiv_t imaxdiv(intmax_t x, intmax_t y) // returns the quotient and remainder
                                          // of x / y

The C99 standard header file <fenv.h> provides access to an IEEE 754‑compliant floating‑point environment for numerical programming. The library introduces two types and numerous macros and functions for managing and controlling floating‑point state.

The new types supported are:

New macros supported include:

New functions include:

int feclearexcept(int ex); // clear floating‑point exceptions selected by ex
int feraiseexcept(int ex); // raise floating point exceptions selected by ex
int fetestexcept(int ex); // test floating point exceptions selected by x
int fegetround(void); // return the current rounding mode
int fesetround(int mode); // set the current rounding mode given by mode
int fegetenv(fenv_t *penv); return the floating‑point environment in penv
int fesetenv(const fenv_t *penv); // set the floating‑point environment to penv

Using the sprintf family of functions found in the C90 standard header <stdio.h> can be dangerous. In the statement:

sprintf(buffer, size, "Error %d: Cannot open file '%s'", errno, filename);

the variable size specifies the minimum number of characters to be inserted into buffer. Consequently, more characters can be output than might fit in the memory allocated to the string.

The snprintf functions found in the C99 version of <stdio.h> are safe versions of the sprintf functions that prevent buffer overrun. In the statement:

snprintf(buffer, size, "Error %d: Cannot open file '%s'", errno, filename);

the variable size specifies the maximum number of characters that can be inserted into buffer. The buffer can never be overrun, provided its size is always greater than the size specified by size.

The new standard header <tgmath.h> defines several families of mathematical functions that are type generic in the sense that they are overloaded on floating‑point types. For example, the trigonometric function cos works as if it has the overloaded declaration:

extern float cos(float x);
extern double cos(double x);
extern long double cos(long double x);
...

A statement such as:

p = cos(0.78539f); // p = cos(pi / 4)

calls the single‑precision version of the cos function, as determined by the type of the literal 0.78539f.