C99 (previously known as C9X) is an informal name for ISO/IEC 9899:1999, a past version of the C programming language standard. It extends the previous version (C90) with new features for the language and the standard library, and helps implementations make better use of available computer hardware, such as the IEEE 754-1985 arithmetic, and compiler technology.. The C11 version (published in 2011) of the standard has replaced it.
After ANSI produced 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, while C++ 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 the working group ISO/IEC JTC1/SC22/WG14.
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 has
int implicitly 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 implicit
int. In practice, compilers are likely to display a warning, then assume
int and 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: variable declaration is no longer restricted to file scope or the start of a compound statement (block), facilitating static single assignment form
- several new data types, including
long long int, optional extended integer types, an explicit boolean data type, and a
complextype to represent complex numbers
- variable-length arrays (although subsequently relegated in C11 to a conditional feature which implementations are not required to support)
- flexible array members
- support for one-line comments beginning with
//, as in BCPL or C++
- new library functions, such as
- new headers, such as
- type-generic math (macro) functions, in
<tgmath.h>, which select a math library function based upon
long doublearguments, etc.
- improved support for IEEE floating point
- designated initializers
- compound literals
- support for variadic macros (macros with a variable number of arguments)
restrictqualification allows more aggressive code optimization, removing compile-time array access advantages previously held by FORTRAN over ANSI C
- universal character names, which allows user variables to contain other characters than the standard character set
Parts of the C99 standard are included in the current version of the C++ standard, C++11, including integer types, headers, and library functions. Variable-length arrays are not among these included parts because C++'s Standard Template Library already 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 of IEEE 754-1985 (also known as IEC 60559) floating point hardware 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 754 single precision,
doubleis defined as double precision, and
long doubleis defined as IEEE 754 extended precision or some form of quad precision where available (e.g., Intel 80 bit double extended precision on x86 or x86-64 platforms), else double precision. Previously, all C90 floating operations were defined to occur in double-precision, with subsequent rounding to single precision, to store results, where necessary.
- The four arithmetic operations and square root are correctly rounded as defined by IEEE 754.
|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 == 2 indicates 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 == 1 performs all internal intermediate expressions in double precision (unless an operand is long double), while FLT_EVAL_METHOD == 0 specifies 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 table on the right.
FLT_EVAL_METHOD == 2 tends to limit the risk of rounding errors affecting numerically unstable expressions (see IEEE 754 design rationale) and is the designed default method for x87 hardware, but yields unintuitive behavior for the unwary user; FLT_EVAL_METHOD == 1 was the default evaluation method originally used in K&R C, which promoted all floats to double in expressions; and FLT_EVAL_METHOD == 0 is also commonly used and specifies a strict "evaluate to type" of the operands. (For gcc, FLT_EVAL_METHOD == 2 is the default on 32 bit x86, and FLT_EVAL_METHOD == 0 is the default on 64 bit x86-64, but FLT_EVAL_METHOD == 2 can be specified on x86-64 with option -mfpmath=387). Note that prior to the precision of intermediate values being precisely specified in C99, C compilers could round intermediate results inconsistently, especially when using x87 floating point hardware, leading to compiler-specific behaviour; such inconsistencies are not permitted in compilers conforming to C99 (annex F).
The following annotated example C99 code for computing a continued fraction function demonstrates the main features:
double compute_fn(double z) // 
#pragma STDC FENV_ACCESS ON // 
assert(FLT_EVAL_METHOD == 2); // 
if (isnan(z)) // 
puts("z is not a number");
puts("z is infinite");
long double r = 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); // 
bool raised = fetestexcept(FE_OVERFLOW); // 
puts("Warning: __STDC_IEC_559__ not defined. IEEE 754 floating point not fully supported."); // 
#pragma STDC FENV_ACCESS ON
fesetround(FE_UPWARD); // 
- Compile with:
gcc -std=c99 -mfpmath=387 -o test_c99_fp -lm test_c99_fp.c
- 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.
- 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.
- The special values such as NaN and positive or negative infinity can be tested and set.
long doubleis defined as IEEE 754 double extended or quad precision if available. Using higher precision than required for intermediate computations can minimize round-off error (the typedef double_t can be used for code that is portable under all FLT_EVAL_METHODs).
- 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. (Note that if FLT_EVAL_METHOD is defined as 2 then all internal computations including constants will be performed in long double precision; if FLT_EVAL_METHOD is defined as 0 then additional care is need to ensure this, including possibly additional casts and explicit specification of constants as long double).
- 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.
- 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).
- __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 shouldn't be).
- 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 defining TEST_NUMERIC_STABILITY_UP etc. in this example, when debugging) can be used to diagnose numerical instability. Note that this method can be used even if compute_fn() is part of a separately compiled binary library. But depending on the function, numerical instabilities cannot always be detected.
A standard macro
__STDC_VERSION__ is defined with value
199901L to 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 that
inline is available in either case (by replacing it with
static in C90 to avoid linker errors.)
#if __STDC_VERSION__ >= 199901L /* "inline" is a keyword */ #else # define inline static #endif
Most C compilers provide support for at least some of the features introduced in C99. However, there has been less support from Microsoft, which used to focus mainly on C++ and only started to implement C99 features in their 2013 offering.
|Implementation||Level of support||Details|
|AMD x86 Open64 Compiler Suite||Mostly||Has C99 support equal to that of GCC.|
|cc65||Partial||Full C89 and 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 minor restrictions on switch statement (no Duff's device) and bitfields.|
|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 June 2014[update] in mainline GCC, extended identifiers, standard pragmas and IEEE 754/IEC 60559 floating point support are missing. Additionally, some features (such as extended integer types and new library functions) must be provided by the C standard library and are thus out of scope for GCC. GCC's 4.6 and 4.7 releases also provides the same level of compliance. Almost complete IEEE 754 support if the hardware is compliant.|
|Green Hills Software||Full|
|IBM C for AIX, V6  and XL C/C++ V11.1 for AIX ||Full|
|IBM Rational logiscope||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 Group PGI C/C++||Full|
|Mostly||Doesn't 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||C99 is not supported as of Visual C++ 2012, while Visual C++ 2013 implements support for a limited subset of C99.|
|Open Watcom||Partial||Implements the most-used parts of the standard. However, they are enabled only through an undocumented command-line switch.|
|Pelles C||Full||Supports all C99 features.|
|Portable C compiler||Partial||Working towards becoming C99-compliant.|
|The Amsterdam Compiler Kit||No||A C99 frontend is currently under investigation.|
|Tiny C Compiler||Partial||Does not support complex numbers. The developers state that "TCC is heading toward full ISOC99 compliance".|
Since ratification of the 1999 C standard, the standards working group prepared technical reports specifying improved support for embedded processing, additional character data types (Unicode support), and library functions with improved bounds checking. Work continues on technical reports addressing decimal floating point, additional mathematical special functions, and additional dynamic memory allocation functions. The C and C++ standards committees have been collaborating on specifications for threaded programming.
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 a memory model, in order to clarify sequence points and to support threaded programming.
- C++ Technical Report 1
- Floating point, for further discussion of usage of IEEE 754 hardware
- "ISO/IEC 9899:1999 - Programming languages - C". Iso.org. 2011-12-08. Retrieved 2014-04-08.
- "Standards - Using the GNU Compiler Collection (GCC)". Gcc.gnu.org. Retrieved 2014-04-08.
- "C Dialect Options - Using the GNU Compiler Collection (GCC)". Gcc.gnu.org. 2009-05-06. Retrieved 2014-04-08.
- "What every programmer should know about memory".
- Doug Priest (1997). "Differences Among IEEE 754 Implementations".
- Jack Woehr (1 November 1997). "A conversation with William Kahan.".
- William Kahan (11 June 1996). "The Baleful Effect of Computer Benchmarks upon Applied Mathematics, Physics and Chemistry".
- William Kahan (11 January 2006). "How Futile are Mindless Assessments of Roundoff in Floating-Point Computation ?".
- Peter Bright (29 June 2013). "C99 acknowledged at last as Microsoft lays out its path to C++14". Ars Technica. Retrieved 9 January 2015.
- "x86 Open64". Developer.amd.com. 1 April 1989. Retrieved 8 June 2009.
- "cc65 - a freeware C compiler for 6502 based systems". Retrieved 14 September 2011.
- "C/C++ interpreter Ch C99 features". SoftIntegration, Inc. 15 February 2008. Retrieved 15 February 2008.
- "Clang Compiler User's Manual". Retrieved 11 January 2010.
- "CompCert C Documentation and User Manual v2.4". Retrieved 14 March 2015.
- "libfirm homepage". Retrieved 4 Feb 2014.
- "C Language Implementation - Digital Mars". Retrieved 14 September 2011.
- "Status of C99 features in GCC". Free Software Foundation, Inc. 12 June 2014. Retrieved 25 August 2014.
- "Status of C99 features in GCC 4.6". Free Software Foundation, Inc. 23 May 2013. Retrieved 23 May 2013.
- "Status of C99 features in GCC 4.7". Free Software Foundation, Inc. 23 May 2013. Retrieved 23 May 2013.
- "Semantics of Floating Point Math in GCC". 10 October 2008. Retrieved 26 August 2013.
- IBM C for AIX, V6.0 Now Supports the C99 Standard
- IBM - XL C/C++ for AIX - United States
- IBM Rational Logiscope support for C99 standard - United States
- Brenner, Pat. "C99 library support in Visual Studio 2013". Visual C++ Team Blog. Retrieved 14 November 2013.
- Reader Q&A: What about VC++ and C99? « Sutter’s Mill
- A.27 Use of C99 Variable Length Arrays
- Microsoft to C99 Developers: Use ISO C
- "C++11/14 STL Features, Fixes, And Breaking Changes In VS 2013 - Visual C++ Team Blog - Site Home - MSDN Blogs". Blogs.msdn.com. 2013-06-28. Retrieved 2014-04-08.
- "C99 compliance in Open Watcom". Retrieved 11 March 2009.
- "Pelles C Overview". January 2013.
- "Sun Studio 12: C Compiler 5.9 Readme". Sun Microsystems, Inc. 31 May 2007. Retrieved 23 September 2012.
- Tiny C Compiler Reference Documentation
- According to the project's TODO list complex types are the only missing C99 feature. Variable Length Arrays have been added in TCC 0.9.26 
- TCC : Tiny C Compiler
- "Standards - Using the GNU Compiler Collection (GCC)". Gcc.gnu.org. Retrieved 2014-04-08.
- Cheng, Harry (1 March 2002). "C99 & Numeric computing". Dr. Dobb's Journal.
- Seebach, Peter (24 March 2004). "Open source development using C99". developerWorks. IBM.
- PDF (3.61 MB)
- Rationale for International Standard—Programming Languages—C Revision 5.10, April-2003, Rationale for C99
C89 / C90 / "ANSI C"
|C language standards||Succeeded by