C99

This article is about the programming language dialect. For other uses, seeC99 (disambiguation).

Cover of the C99 standards document

C99(previouslyC9X,formallyISO/IEC 9899:1999) is a past version of theCprogramming languageopen standard.It extends the previous version (C90) with new features for the language and thestandard library,and helps implementations make better use of available computer hardware, such asIEEE 754-1985floating-point arithmetic,and compiler technology.TheC11version of the C programming language standard, published in 2011, updates C99.

History

AfterANSIproduced the official standard for the C programming language in 1989, which became an international standard in 1990, the C language specification remained relatively static for some time, whileC++continued to evolve, largely during its own standardization effort. Normative Amendment 1 created a new standard for C in 1995, but only to correct some details of the 1989 standard and to add more extensive support for international character sets. The standard underwent further revision in the late 1990s, leading to the publication of ISO/IEC 9899:1999 in 1999, which was adopted as an ANSI standard in May 2000. The language defined by that version of the standard is commonly referred to as "C99". The international C standard is maintained by theworking groupISO/IEC JTC1/SC22/WG14.

Design

C99 is, for the most part, backward compatible with C89, but it is stricter in some ways.

In particular, a declaration that lacks a type specifier no longer hasintimplicitly assumed. The C standards committee decided that it was of more value for compilers to diagnose inadvertent omission of the type specifier than to silently process legacy code that relied on implicitint.In practice, compilers are likely to display a warning, then assumeintand continue translating the program.

C99 introduced several new features, many of which had already been implemented as extensions in several compilers:

• inline functions
• intermingled declarations and code:variabledeclaration is no longer restricted to file scope or the start of a compound statement (block)
• several newdata types,includinglong long int,optional extended integer types, an explicitBoolean data type,and acomplextype to representcomplex numbers
• variable-length arrays(although subsequently relegated inC11to a conditional feature that implementations are not required to support)
• flexible array members
• support for one-linecommentsbeginning with//,as inBCPL,C++andJava
• new library functions, such assnprintf
• newheaders,such as<stdbool.h>,<complex.h>,<tgmath.h>,and<inttypes.h>
• type-generic math (macro) functions, in<tgmath.h>,which select amath libraryfunctionbased uponfloat,double,orlong doublearguments, etc.
• improved support forIEEE floating point
• designated initializers (for example, initializing a structure by field names:struct point p = {.x = 1,.y = 2 };)
• compound literals (for instance, it is possible to construct structures in function calls:function((struct x) {1, 2}))
• support forvariadic macros(macros with a variable number of arguments)
• restrictqualification allows more aggressive codeoptimization,removing compile-time array access advantages previously held byFORTRANover ANSI C
• universal character names, which allows user variables to contain other characters than the standard character set: four-digit\u0040or eight-digit hexadecimal sequences\U0001f431
• keywordstaticin array indices in parameter declarations

Parts of the C99 standard are included in the current version of theC++standard, including integer types, headers, and library functions. Variable-length arrays are not among these included parts because C++'sStandard Template Libraryalready includes similar functionality.

IEEE 754 floating-point support

A major feature of C99 is its numerics support, and in particular its support for access to the features ofIEEE 754-1985(also known as IEC 60559)floating-pointhardware present in the vast majority of modern processors (defined in "Annex F IEC 60559 floating-point arithmetic" ). Platforms without IEEE 754 hardware can also implement it in software.

On platforms with IEEE 754 floating point:

• floatis defined as IEEE 754single precision,doubleis defined asdouble precision,andlong doubleis defined as IEEE 754extended precision(e.g., Intel 80-bitdouble extendedprecision onx86orx86-64platforms), or some form ofquad precisionwhere available; otherwise, it is double precision.
• The four arithmetic operations and square root are correctly rounded as defined by IEEE 754.

  FLT_EVAL_METHOD	float	double	long double
  0	float	double	long double
  1	double	double	long double
  2	long double	long double	long double

• Expression evaluation is defined to be performed in one of three well-defined methods, indicating whether floating-point variables are first promoted to a more precise format in expressions:FLT_EVAL_METHOD == 2indicates that all internal intermediate computations are performed by default at high precision (long double) where available (e.g.,80 bit double extended),FLT_EVAL_METHOD == 1performs all internal intermediate expressions in double precision (unless an operand is long double), whileFLT_EVAL_METHOD == 0specifies each operation is evaluated only at the precision of the widest operand of each operator. The intermediate result type for operands of a given precision are summarized in the adjacent table.

FLT_EVAL_METHOD == 2tends to limit the risk ofrounding errorsaffecting numerically unstable expressions (seeIEEE 754 design rationale) and is the designed default method forx87hardware, but yields unintuitive behavior for the unwary user;FLT_EVAL_METHOD == 1was the default evaluation method originally used inK&R C,which promoted all floats to double in expressions; andFLT_EVAL_METHOD == 0is also commonly used and specifies a strict "evaluate to type" of the operands. (Forgcc,FLT_EVAL_METHOD == 2is the default on 32 bit x86, andFLT_EVAL_METHOD == 0is the default on 64 bit x86-64, butFLT_EVAL_METHOD == 2can be specified on x86-64 with option -mfpmath=387.) Before C99, compilers could round intermediate results inconsistently, especially when usingx87floating-point hardware, leading to compiler-specific behaviour;such inconsistencies are not permitted in compilers conforming to C99 (annex F).

Example

The following annotated example C99 code for computing a continued fraction function demonstrates the main features:

#include<stdio.h>
#include<math.h>
#include<float.h>
#include<fenv.h>
#include<tgmath.h>
#include<stdbool.h>
#include<assert.h>

doublecompute_fn(doublez)// [1]
{
#pragma STDC FENV_ACCESS ON// [2]

assert(FLT_EVAL_METHOD==2);// [3]

if(isnan(z))// [4]
puts("z is not a number");

if(isinf(z))
puts("z is infinite");

longdoubler=7.0-3.0/(z-2.0-1.0/(z-7.0+10.0/(z-2.0-2.0/(z-3.0))));// [5, 6]

feclearexcept(FE_DIVBYZERO);// [7]

boolraised=fetestexcept(FE_OVERFLOW);// [8]

if(raised)
puts("Unanticipated overflow.");

returnr;
}

intmain(void)
{
#ifndef __STDC_IEC_559__
puts("Warning: __STDC_IEC_559__ not defined. IEEE 754 floating point not fully supported.");// [9]
#endif

#pragma STDC FENV_ACCESS ON

#ifdef TEST_NUMERIC_STABILITY_UP
fesetround(FE_UPWARD);// [10]
#elif TEST_NUMERIC_STABILITY_DOWN
fesetround(FE_DOWNWARD);
#endif

printf("%.7g\n",compute_fn(3.0));
printf("%.7g\n",compute_fn(NAN));

return0;
}

Footnotes:

1. Compile with:gcc-std=c99-mfpmath=387-otest_c99_fptest_c99_fp.c-lm
2. As the IEEE 754 status flags are manipulated in this function, this #pragma is needed to avoid the compiler incorrectly rearranging such tests when optimising. (Pragmas are usually implementation-defined, but those prefixed withSTDCare defined in the C standard.)
3. C99 defines a limited number of expression evaluation methods: the current compilation mode can be checked to ensure it meets the assumptions the code was written under.
4. The special values such asNaNand positive or negative infinity can be tested and set.
5. long doubleis defined as IEEE 754 double extended or quad precision if available. Using higher precision than required for intermediate computations can minimizeround-off error(thetypedefdouble_tcan be used for code that is portable under allFLT_EVAL_METHODs).
6. The main function to be evaluated. Although it appears that some arguments to this continued fraction, e.g., 3.0, would lead to a divide-by-zero error, in fact the function is well-defined at 3.0 and division by 0 will simply return a +infinity that will then correctly lead to a finite result: IEEE 754 is defined not to trap on such exceptions by default and is designed so that they can very often be ignored, as in this case. (IfFLT_EVAL_METHODis defined as 2 then all internal computations including constants will be performed in long double precision; ifFLT_EVAL_METHODis defined as 0 then additional care is need to ensure this, including possibly additional casts and explicit specification of constants as long double.)
7. As the raised divide-by-zero flag is not an error in this case, it can simply be dismissed to clear the flag for use by later code.
8. In some cases, other exceptions may be regarded as an error, such as overflow (although it can in fact be shown that this cannot occur in this case).
9. __STDC_IEC_559__is to be defined only if "Annex F IEC 60559 floating-point arithmetic" is fully implemented by the compiler and the C library (users should be aware that this macro is sometimes defined while it should not be).
10. The default rounding mode is round to nearest (with the even rounding rule in the halfway cases) for IEEE 754, but explicitly setting the rounding mode toward + and - infinity (by definingTEST_NUMERIC_STABILITY_UPetc. in this example, when debugging) can be used to diagnose numerical instability.This method can be used even ifcompute_fn()is part of a separately compiled binary library. But depending on the function, numerical instabilities cannot always be detected.

Version detection

A standard macro__STDC_VERSION__is defined with value199901Lto indicate that C99 support is available. As with the__STDC__macro for C90,__STDC_VERSION__can be used to write code that will compile differently for C90 and C99 compilers, as in this example that ensures thatinlineis available in either case (by replacing it withstaticin C90 to avoid linker errors).

#if __STDC_VERSION__ >= 199901L
/* "inline" is a keyword */
#else
# define inline static
#endif

Implementations

Most C compilers provide support for at least some of the features introduced in C99.

Historically,Microsofthas been slow to implement new C features in theirVisual C++tools, instead focusing mainly on supporting developments in the C++ standards.However, with the introduction of Visual C++ 2013 Microsoft implemented a limited subset of C99, which was expanded in Visual C++ 2015.

Compiler	Level of support	C99 compatibility details
Acorn C/C++	Partial	The official documentation states that "most" compiler features are supported, along with "some" of the library functions.
AMD x86Open64 Compiler Suite	Mostly	Has C99 support equal to that of GCC.
cc65	Partial	FullC89and C99 support is not implemented, partly due to platform limitations (MOS Technology 6502). There is no support planned for some C99 types like _Complex and 64-bit integers (long long).
Ch	Partial	Supports major C99 features.
Clang	Mostly	Supports all features except C99 floating-point pragmas.
CompCert	Mostly	A certified compiler, formally proved correct. Supports all features except C99 complex numbers and VLA, and minor restrictions on switch statements (noDuff's device).
cparser	Full	Supports C99 features.
C++ Builder	Only in 64-bit mode, since latter is CLang fork
Digital Mars C/C++ Compiler	Partial	Lacks support for some features, such as <tgmath.h> and _Pragma.
GCC	Mostly	As of July 2021,standard pragmas and IEEE 754/IEC 60559 floating-point support are missing in mainline GCC. Additionally, some features (such as extended integer types and new library functions) must be provided by the C standard library and are out of scope for GCC.GCC's 4.6 and 4.7 releases also provide the same level of compliance.Partial IEEE 754 support, even when the hardware is compliant: some compiler options may be needed to avoid incorrect optimizations (e.g.,-std=c99and-fsignaling-nans), but full support of directed rounding modes is missing even when-frounding-mathis used.
Green Hills Software	Full
IBM C for AIX, V6andXL C/C++V11.1 for AIX	Full
IBM Rationallogiscope	Full	Until Logiscope 6.3, only basic constructs of C99 were supported. C99 is officially supported in Logiscope 6.4 and later versions.
The Portland GroupPGI C/C++	Full
IAR Systems Embedded Workbench	Mostly	Does not support UCN (universal character names). Compiler for embedded targets, such as ARM, Coldfire, MSP430, AVR, AVR32, 8051,... No x86 targets.
Intel C++ compiler	Mostly
Microsoft Visual C++	Partial	Visual C++ 2012 and earlier did not support C99. Visual C++ 2013 implements a limited subset of C99 required to compile popular open-source projects. Visual C++ 2015 implements the C99 standard library, with the exception of any library features that depend on compiler features not yet supported by the compiler (for example, <tgmath.h> is not implemented). Visual C++ 2019 (16.6) adds opt-in support for a C99 conformant preprocessor.
Open Watcom	Partial	Implements the most commonly used parts of the standard. However, they are enabled only through the undocumented command-line switch "-za99". Three C99 features have been bundled as C90 extensions since pre-v1.0: C++ style comments (//), flexible array members, trailing comma allowed in enum declaration.
Pelles C	Full	Supports all C99 features.
Portable C compiler	Partial	Working towards becoming C99-compliant.
Sun Studio	Full
TheAmsterdam Compiler Kit	No	A C99 frontend is currently under investigation.
Tiny C Compiler	Partial	Does not support complex numbers.Variable Length Arrays are supported but not as arguments in functions.The developers state that "TCC is heading toward full ISOC99 compliance".
vbcc	Partial

Future work

Since ratification of the 1999 C standard, the standards working group prepared technical reports specifying improved support for embedded processing, additional character data types (Unicodesupport), and library functions with improvedbounds checking.Work continues on technical reports addressing decimalfloating point,additional mathematicalspecial functions,and additionaldynamic memory allocationfunctions. The C and C++ standards committees have been collaborating on specifications forthreadedprogramming.

The next revision of the C standard,C11,was ratified in 2011.The C standards committee adopted guidelines that limited the adoption of new features that have not been tested by existing implementations. Much effort went into developing amemory model,in order to clarifysequence pointsand to supportthreadedprogramming.

See also

• C++23,C++20,C++17,C++14,C++11,C++03,C++98,versions of the C++ programming language standard
• Compatibility of C and C++
• C++ Technical Report 1
• Floating point,for further discussion of usage of IEEE 754 hardware

Further reading

• N1256(final draft of C99 standard plus TC1, TC2, TC3); WG14; 2007. (HTML and ASCII versions)
• ISO/IEC 9899:1999(official C99 standard);ISO;1999.
• Rationale for C99;WG14; 2003.
• Cheng, Harry (1 March 2002)."C99 & Numeric computing".Dr. Dobb's Journal.
• Seebach, Peter (24 March 2004)."Open source development using C99".developerWorks.IBM.

External links

• C Language Working Group 14 (WG14) Documents
• C9X Charter- WG14
• New things in C9X
• Features of C99