Latest changes in C11

Question

C1x has become ISO/IEC 9899:2011 aka C11.

Does anyone know what changes (if any) there are in the Standard from the April 2011 draft n1570?

ETA: There are the Committee minutes from London (March 2011) (which should be included in n1570) here, and from Washington, DC (October 2011) here; I suppose a list of accepted changes in the DC minutes should cover things.

Answer 1

I just learned today that there was one (somewhat) significant change between N1570 and the final C11 standard (ISO/IEC 9899:2011 (E)).

In N1570, 6.3.2p3 says:

Except when it is the operand of the sizeof operator, the _Alignof operator, or the unary & operator, or is a string literal used to initialize an array, an expression that has type "array of type" is converted to an expression with type "pointer to type" that points to the initial element of the array object and is not an lvalue.

The inclusion of _Alignof was an error, since the syntax of a unary-expression permits

_Alignof ( type-name )

but not

_Alignof unary-expression

The released C11 standard corrects this error and reverts to the C99 wording:

Except when it is the operand of the sizeof operator, or the unary & operator, or is a string literal used to initialize an array, an expression that has type "array of type" is converted to an expression with type "pointer to type" that points to the initial element of the array object and is not an lvalue.

More information: in a recent posting to comp.std.c about differences between N1570 and the released standard, Larry Jones, a member of the ISO C committee, wrote:

There are a number of them, but most are just minor editorial tweaks, changes to boilerplate text, and shuffling things around to keep the powers that be happy. The biggest change was removing _Alignof from a bunch of places it shouldn't have been added (based on the erroneous notion that it takes either a type or an expression like sizeof does when it really only takes a type): 6.3.2.1p2, p3, p4, fn. 65; and 6.7.1 fn. 121.

Message-ID: <rfg33a-u0q.ln1@jones.homeip.net>

Here's the thread as seen on groups.google.com.

Answer 2

Answered by Jens Gustedt in the comments:

According to a comment by Larry Jones on comp.std.c there were no significant changes from N1569 (which is N1570 without change markers). The only thing that remains unsolved is the value for __STDC_VERSION__, but I guess most naturally it will be 201112L.

Answer 3

ISO has ratified and published as ISO/IEC 9899:2011 the new C11 (C1x) standard for the C programming language. The major changes from the previous standard (C99), as written in the C11 Wikipedia article, are the following:

The standard includes several changes to the C99 language and library specifications, such as:

• Alignment specification (_Alignas specifier, _Alignof operator, aligned_alloc function, <stdalign.h> header file)
• The _Noreturn function specifier

• Type-generic expressions using the _Generic keyword. For example, the following macro cbrt(x) translates to cbrtl(x), cbrt(x) or cbrtf(x) depending on the type of x:

      #define cbrt(X) _Generic((X), long double: cbrtl, \
                                    default: cbrt, \
                                    float: cbrtf)(X)
  

• Multithreading support (_Thread_local storage-class specifier, <threads.h> header including thread creation/management functions, mutex, condition variable and thread-specific storage functionality, as well as the _Atomic type qualifier and <stdatomic.h> for uninterruptible object access).
• Improved Unicode support based on the C Unicode Technical Report ISO/IEC TR 19769:2004 (char16_t and char32_t types for storing UTF-16/UTF-32 encoded data, including conversion functions in <uchar.h> and the corresponding u and U string literal prefixes, as well as the u8 prefix for UTF-8 encoded literals).
• Removal of the gets function, deprecated in the previous C language standard revision, ISO/IEC 9899:1999/Cor.3:2007(E), in favor of a new safe alternative, gets_s.
• Bounds-checking interfaces (Annex K).
• Analyzability features (Annex L).
• More macros for querying the characteristics of floating point types, concerning subnormal floating point numbers and the number of decimal digits the type is able to store.
• Anonymous structures and unions, useful when unions and structures are nested, e.g. in struct T { int tag; union { float x; int n; }; };.
• Static assertions, which are evaluated during translation at a later phase than #if and #error, when types are understood by the translator.
• An exclusive create-and-open mode ("…x" suffix) for fopen. This behaves like O_CREAT|O_EXCL in POSIX, which is commonly used for lock files.
• The quick_exit function as a third way to terminate a program, intended to do at least minimal deinitializition if termination with exit fails.
• Macros for the construction of complex values (partly because real + imaginary*I might not yield the expected value if imaginary is infinite or NaN).

From the ISO site you can buy the full published standard. Here is an abstract taken from the ISO site:

ISO/IEC 9899:2011 specifies the form and establishes the interpretation of programs written in the C programming language. It specifies

• the representation of C programs;
• the syntax and constraints of the C language;
• the semantic rules for interpreting C programs;
• the representation of input data to be processed by C programs;
• the representation of output data produced by C programs;
• the restrictions and limits imposed by a conforming implementation of C.

ISO/IEC 9899:2011 does not specify

• the mechanism by which C programs are transformed for use by a data-processing system;
• the mechanism by which C programs are invoked for use by a data-processing system;
• the mechanism by which input data are transformed for use by a C program;
• the mechanism by which output data are transformed after being produced by a C program;
• the size or complexity of a program and its data that will exceed the capacity of any specific data-processing system or the capacity of a particular processor;
• all minimal requirements of a data-processing system that is capable of supporting a conforming implementation. ISO/IEC 9899:2011 is designed to promote the portability of C programs among a variety of data-processing systems. It is intended for use by implementers and programmers.