C Standards: ANSI, C99, C11, C23

Why Standardization Matters

In C's early years, different compilers implemented the language slightly differently. Code that worked with one compiler might fail with another. This fragmentation threatened C's core promise: write once, compile anywhere. Standardization solved this problem by creating official specifications that all compilers must follow, ensuring portable code across platforms and compilers.

The standardization process also provides a formal mechanism for evolving the language. New features can't just appear randomly in compilers; they go through rigorous committee review, ensuring they're well-designed, implementable, and compatible with existing code. This careful process has kept C stable and predictable for decades while allowing controlled modernization.

K&R C (1978)

Before official standardization, the C language was defined by "The C Programming Language" book by Brian Kernighan and Dennis Ritchie, published in 1978. This version, known as K&R C, was the de facto standard. It documented C as it existed in early Unix systems and became the reference for compiler implementers.

K&R C had a simpler function declaration syntax than modern C. You didn't declare parameter types in the function signature; instead, you declared them separately. This made code more verbose but was considered acceptable for the era. The language was already powerful with most features we recognize today: pointers, structures, arrays, and basic control flow.

/* K&R C style function declaration */
int add(a, b)
int a;
int b;
{
    return a + b;
}

/* Modern C style (ANSI C and later) */
int add(int a, int b) {
    return a + b;
}

ANSI C / C89 / C90 (1989)

The first official C standard was published by the American National Standards Institute (ANSI) in 1989, designated as ANSI X3.159-1989. The International Organization for Standardization (ISO) adopted it in 1990 as ISO/IEC 9899:1990, hence the names C89 and C90 (they refer to the same standard). This was the first time C had an official, implementation-independent specification.

ANSI C introduced function prototypes where you declare parameter types in the function signature. This allowed compilers to catch more errors at compile time by verifying that function calls match declarations. The standard also formally defined the standard library, including stdio.h, stdlib.h, string.h, and other essential headers that are now universal across C implementations.

Other important ANSI C additions included const and volatile type qualifiers, which provided finer control over how variables behave. The void type was standardized for functions that don't return values or for generic pointers. Enumerated types became official, and the preprocessor capabilities were formally specified with stringification and token concatenation operators.

C99 (1999)

C99, published as ISO/IEC 9899:1999, was the first major update to C, arriving a decade after ANSI C. This standard added numerous features that modernized the language while maintaining backward compatibility. Many of these features addressed pain points that C programmers had struggled with for years.

One of the most significant C99 additions was inline functions, allowing programmers to suggest that small functions be expanded inline for performance without resorting to macros. Variable-length arrays (VLAs) let you create arrays whose size is determined at runtime, not compile time, though this feature remains controversial due to stack overflow risks.

C99 introduced the long long integer type for 64-bit integers, essential as computing moved beyond 32-bit systems. Complex number support became part of the language with complex.h. Single-line comments using // were officially adopted from C++. The ability to declare variables anywhere in a block (not just at the beginning) made code more readable.

The standard also added several useful library functions and headers. <stdint.h> provided fixed-width integer types like int32_t and uint64_t, crucial for portable code that needs specific bit widths. <stdbool.h> finally gave C a proper boolean type. snprintf() provided safe string formatting that won't overflow buffers.

/* C99 features in action */
#include <stdio.h>
#include <stdint.h>  // C99: Fixed-width integers
#include <stdbool.h> // C99: Boolean type

int main(void) {
    // C99: Declare variables anywhere
    for (int i = 0; i < 10; i++) {  // C99: for loop declaration
        printf("%d\n", i);
    }
    
    // C99: Boolean type
    bool is_valid = true;
    
    // C99: Fixed-width integers
    int32_t value = 42;
    uint64_t large = 1234567890123ULL;
    
    // C99: Single-line comments
    // This is much nicer than /* */ for short comments
    
    return 0;
}

C11 (2011)

C11 (ISO/IEC 9899:2011) arrived after a 12-year gap, focusing on safety, concurrency, and alignment with C++. The standard recognized that modern computing is multithreaded and that security vulnerabilities in C code were causing significant problems worldwide. C11 addressed these concerns while remaining conservative about changes.

The most significant C11 addition was native support for multithreading. The threads.h header provided standard threading primitives that work across platforms. Previously, programmers used platform-specific APIs like pthreads (Unix) or Windows threads. Now, C had a portable threading model, though adoption has been slow since established code uses existing threading libraries.

C11 introduced atomic operations through stdatomic.h, providing lock-free atomic types and operations. This is crucial for high-performance concurrent programming where traditional locks are too slow. The _Generic keyword enabled a form of compile-time polymorphism, allowing functions to work with multiple types without macros or function overloading.

Security improvements included optional bounds-checking interfaces in Annex K. These provide safer versions of dangerous functions like strcpy() and gets(), though their adoption has been limited due to performance concerns and the fact that they're optional. C11 also deprecated and removed gets() entirely after decades of it causing buffer overflow vulnerabilities.

/* C11 features */
#include <threads.h>      // C11: Threading support
#include <stdatomic.h>    // C11: Atomic operations

// C11: Thread function
int thread_func(void *arg) {
    printf("Thread running\n");
    return 0;
}

int main(void) {
    // C11: Anonymous structures/unions
    struct {
        int x, y;
        struct {
            int r, g, b;
        };  // Anonymous
    } point = {10, 20, 255, 0, 0};
    
    // C11: Atomic variable
    atomic_int counter = ATOMIC_VAR_INIT(0);
    atomic_fetch_add(&counter, 1);
    
    // C11: Thread creation
    thrd_t thread;
    thrd_create(&thread, thread_func, NULL);
    thrd_join(thread, NULL);
    
    // C11: Static assertions
    _Static_assert(sizeof(int) >= 4, "int must be at least 4 bytes");
    
    return 0;
}

C17 (2018)

C17 (ISO/IEC 9899:2018), also called C18, was not a major update. It contained only bug fixes and clarifications to C11; no new features were added. This "technical corrigendum" ensured the standard was clear and consistent, addressing ambiguities discovered during C11 implementation and use.

While C17 didn't add features, it's important for standardizing behavior across compilers. Different interpretations of ambiguous spec text led to subtle portability issues. C17 resolved these, ensuring that conforming compilers behave identically on all platforms.

C23 (Expected 2023-2024)

C23 (ISO/IEC 9899:2023), currently in final stages, represents the next major evolution of C. It focuses on convenience features, safety improvements, and modernization without breaking existing code. Some features borrow successful concepts from C++ where appropriate.

Notable C23 additions include binary literals (0b prefix), improved compatibility with C++, and better support for Unicode. The standard introduces attributes similar to C++, allowing compilers to receive hints about code properties. Digit separators make large numbers more readable (1'000'000 instead of 1000000).

/* C23 features (preview) */
#include <stdio.h>

int main(void) {
    // C23: Binary literals
    int flags = 0b101010;
    
    // C23: Digit separators for readability
    long population = 8'000'000'000;
    
    // C23: typeof (type inference)
    int x = 42;
    typeof(x) y = x;  // y is also int
    
    // C23: #elifdef and #elifndef
    #ifdef DEBUG
        printf("Debug mode\n");
    #elifdef TESTING
        printf("Test mode\n");
    #endif
    
    // C23: nullptr constant (like C++)
    int *ptr = nullptr;
    
    return 0;
}

Which Standard Should You Use?

For modern development, target C11 as a minimum, with C17 recommended. C11 is widely supported by major compilers (GCC, Clang, MSVC) and provides important features like better variable declaration and standard threading. C17, being only bug fixes to C11, is essentially the same standard with corrections.

Avoid targeting C89/C90 unless you're working on legacy systems or embedded platforms with outdated compilers. The limitations (variables only at block start, no single-line comments, no stdint.h) make code harder to write and read. Most modern codebases won't compile without at least C99 features.

C23 features should be used cautiously until widespread compiler support stabilizes. Early adoption helps test new features, but production code needs compatibility. Check your compiler's C23 support status before using new features.

When learning C, focus on features common to C99 and later standards. These are universally available and represent modern C programming. Understanding the evolution helps you read older code and appreciate why certain features exist, but write new code using modern standards.

Summary & What's Next