C23 Standard: Modern Features Complete Guide for Developers

The C programming language has been the backbone of systems programming for decades. With the release of the C23 standard (ISO/IEC 9899:2023), C receives its most significant update since C11, bringing modern features that improve safety, readability, and developer productivity. If you've been writing C code with the C11 or earlier standards, you'll find that C23 addresses long-standing pain points: the ambiguity of NULL, the awkwardness of _Bool, and the lack of standardized annotations for compilers. This guide explores the key features of C23 with practical, production-ready examples. You'll learn how to use nullptr to avoid pointer-related bugs, how the new bool type simplifies Boolean logic, how attributes like [[nodiscard]] enforce correct API usage, and how digit separators make numeric literals more readable. We also cover the new preprocessor directives #elifdef and #elifndef, and the unreachable() macro for optimization. By the end, you'll be equipped to write safer, cleaner C code that leverages the best of modern C. Whether you're maintaining legacy systems or starting a new project, understanding C23 is essential for staying current in the C ecosystem.

1. nullptr: The Type-Safe Null Pointer

One of the most anticipated features in C23 is the introduction of nullptr as a keyword. In previous standards, null pointers were represented by the macro NULL, which is typically defined as ((void*)0) or 0. This caused ambiguity in function overloading (in C++) and could lead to subtle bugs when passing NULL to variadic functions or in contexts where an integer zero is expected. C23's nullptr is a keyword of type nullptr_t, which implicitly converts to any pointer type but not to integer types. This eliminates the ambiguity and improves type safety. For example:

``c int *ptr = nullptr; // OK, implicit conversion int x = nullptr; // Compiler error: cannot convert nullptr_t to int ``

To use nullptr, ensure your compiler supports C23 (GCC 14+, Clang 17+). The following example demonstrates its usage in a function that returns a pointer:

```c #include <stdio.h>

int find_value(int arr, int size, int target) { for (int i = 0; i < size; i++) { if (arr[i] == target) { return &arr[i]; } } return nullptr; // Use nullptr instead of NULL }

int main() { int data[] = {1, 2, 3, 4, 5}; int result = find_value(data, 5, 3); if (result != nullptr) { printf("Found: %d ", result); } else { printf("Not found "); } return 0; } ```

Output: `` Found: 3 ``

Using nullptr makes the code's intent clearer and prevents accidental misuse. It is recommended to replace all uses of NULL with nullptr in new C23 code.

#include <stdio.h>

int* find_value(int *arr, int size, int target) {
    for (int i = 0; i < size; i++) {
        if (arr[i] == target) {
            return &arr[i];
        }
    }
    return nullptr;
}

int main() {
    int data[] = {1, 2, 3, 4, 5};
    int *result = find_value(data, 5, 3);
    if (result != nullptr) {
        printf("Found: %d\n", *result);
    } else {
        printf("Not found\n");
    }
    return 0;
}

2. bool: A Proper Boolean Type

C23 promotes bool, true, and false to keywords, making them first-class citizens of the language. Previously, C used _Bool as the boolean type, with bool, true, and false defined as macros in <stdbool.h>. Now, you can use bool directly without including any header, and true and false are keywords as well. This simplifies code and aligns C with C++ in terms of boolean handling. The bool type is still an unsigned integer type that can hold only 0 or 1, but the keyword usage makes code cleaner. Example:

```c #include <stdio.h>

bool is_even(int n) { return n % 2 == 0; }

int main() { int num = 4; if (is_even(num)) { printf("%d is even ", num); } else { printf("%d is odd ", num); } return 0; } ```

Output: `` 4 is even ``

Note that _Bool is still available for backward compatibility, but the new keywords are preferred. The header <stdbool.h> now simply defines bool as _Bool (which is the same keyword) for compatibility with older code. In C23, you can write bool flag = true; without any includes.

#include <stdio.h>

bool is_even(int n) {
    return n % 2 == 0;
}

int main() {
    int num = 4;
    if (is_even(num)) {
        printf("%d is even\n", num);
    } else {
        printf("%d is odd\n", num);
    }
    return 0;
}

3. Attributes: Standardized Annotations

C23 introduces a standardized attribute syntax using double square brackets [[attribute]]. This feature, borrowed from C++, allows programmers to give hints to the compiler about code behavior, such as deprecation, unused results, or fallthrough in switch statements. The most useful attributes in C23 are:

• [[deprecated]]: Marks a function or variable as deprecated, causing a warning when used.
• [[deprecated("message")]]: Provides a custom deprecation message.
• [[nodiscard]]: Warns if the return value of a function is ignored.
• [[maybe_unused]]: Suppresses warnings about unused variables or functions.
• [[fallthrough]]: Indicates intentional fallthrough in a switch case.

Example:

```c #include <stdio.h>

[[nodiscard]] int compute_value() { return 42; }

[[deprecated("Use new_function instead")]] void old_function() { // ... }

int main() { // Warning: ignoring return value of 'compute_value' compute_value(); // Warning: 'old_function' is deprecated old_function(); return 0; } ```

When compiled with warnings enabled (e.g., -Wall), the compiler will emit warnings for the above code. Attributes help enforce coding standards and catch potential bugs early.

#include <stdio.h>

[[nodiscard]] int compute_value() {
    return 42;
}

[[deprecated("Use new_function instead")]]
void old_function() {
    // ...
}

int main() {
    compute_value();  // Warning: ignoring return value
    old_function();   // Warning: deprecated
    return 0;
}

4. Digit Separators: Readable Numeric Literals

C23 allows single quotes (') as digit separators in numeric literals to improve readability. This is especially useful for large numbers, bit patterns, and hexadecimal constants. The separator can be placed between digits but not at the beginning or end. Examples:

``c int million = 1'000'000; // 1,000,000 long long big = 123'456'789'012; // 123,456,789,012 unsigned int mask = 0xFF'00'FF; // 0xFF00FF float pi = 3.141'592'653; // 3.141592653 ``

Digit separators have no effect on the value; they are purely cosmetic. They help avoid off-by-one errors when counting digits. Example usage:

```c #include <stdio.h>

int main() { int population = 8'000'000'000; // 8 billion printf("World population: %d ", population); unsigned int color = 0x00'FF'00; // Green printf("Green color code: 0x%06X ", color); return 0; } ```

Output: `` World population: 8000000000 Green color code: 0x00FF00 ``

Note that the output does not include separators; they are only in the source code.

#include <stdio.h>

int main() {
    int population = 8'000'000'000;
    printf("World population: %d\n", population);
    
    unsigned int color = 0x00'FF'00;
    printf("Green color code: 0x%06X\n", color);
    
    return 0;
}

5. Preprocessor Enhancements: #elifdef and #elifndef

C23 adds #elifdef and #elifndef directives to the preprocessor, complementing the existing #ifdef and #ifndef. These allow for more concise conditional compilation chains. Previously, to check for multiple macros, you had to use nested #ifdef or combine with #elif defined(...). Now you can write:

``c #ifdef FEATURE_A // code for A #elifdef FEATURE_B // code for B #elifndef FEATURE_C // code if C is not defined #else // default code #endif ``

This is equivalent to:

``c #if defined(FEATURE_A) // code for A #elif defined(FEATURE_B) // code for B #elif !defined(FEATURE_C) // code if C is not defined #else // default code #endif ``

The new directives reduce boilerplate and improve readability. Example:

```c #include <stdio.h>

#define PLATFORM_LINUX

int main() { #ifdef PLATFORM_WINDOWS printf("Windows "); #elifdef PLATFORM_LINUX printf("Linux "); #elifdef PLATFORM_MAC printf("Mac "); #else printf("Unknown platform "); #endif return 0; } ```

Output: `` Linux ``

This feature simplifies platform-specific code and configuration management.

#include <stdio.h>

#define PLATFORM_LINUX

int main() {
#ifdef PLATFORM_WINDOWS
    printf("Windows\n");
#elifdef PLATFORM_LINUX
    printf("Linux\n");
#elifdef PLATFORM_MAC
    printf("Mac\n");
#else
    printf("Unknown platform\n");
#endif
    return 0;
}

6. The unreachable() Macro

C23 introduces the unreachable() macro, defined in <stddef.h>, to mark code paths that should never be executed. This is a hint to the compiler for optimization and can help suppress warnings about uninitialized variables or missing return statements. If the code is actually reached, behavior is undefined (similar to __builtin_unreachable() in GCC/Clang). Example:

```c #include <stdio.h> #include <stddef.h> // for unreachable()

enum Color { RED, GREEN, BLUE };

const char* color_name(enum Color c) { switch (c) { case RED: return "Red"; case GREEN: return "Green"; case BLUE: return "Blue"; default: unreachable(); // All cases covered } }

int main() { printf("%s ", color_name(RED)); return 0; } ```

Output: `` Red ``

Without unreachable(), the compiler might warn about control reaching the end of a non-void function. Using it tells the compiler that the default case is impossible, allowing better optimization and cleaner code.

#include <stdio.h>
#include <stddef.h>

enum Color { RED, GREEN, BLUE };

const char* color_name(enum Color c) {
    switch (c) {
        case RED:   return "Red";
        case GREEN: return "Green";
        case BLUE:  return "Blue";
        default:    unreachable();
    }
}

int main() {
    printf("%s\n", color_name(RED));
    return 0;
}

7. Other Notable Features

C23 includes several other improvements that enhance the language's expressiveness and safety:

• #warning directive: Emits a warning during preprocessing, useful for deprecation notices.
• #embed directive: (Optional) Embeds binary files as byte arrays at compile time.
• typeof operator: Returns the type of an expression, similar to decltype in C++.
• constexpr: (Not yet in C23, but planned for future) – C23 does not include constexpr; that is expected in C2Y.
• static_assert with no message: static_assert(condition) is now allowed without a message string.
• alignof and alignas: Standardized alignment control (already in C11, but refined).

Example of #warning:

``c #warning "This code is deprecated, use new version" ``

Example of typeof:

```c #include <stdio.h>

int main() { int x = 10; typeof(x) y = 20; // y is int printf("%d ", y); return 0; } ```

Output: `` 20 ``

These features, while not as groundbreaking as nullptr or bool, contribute to a more modern and robust C programming experience.

#include <stdio.h>

int main() {
    int x = 10;
    typeof(x) y = 20;
    printf("%d\n", y);
    return 0;
}