C Standards and C23

#include <stdio.h>

int main(void)
{
    // All four are KEYWORDS in C23; <stdbool.h> is no longer needed.
    bool ready = true;
    bool done = false;

    // static_assert and thread_local likewise -- no <assert.h> macro,
    // no _Static_assert/_Thread_local spelling required.
    static_assert(sizeof(int) >= 2, "int must be at least 16 bits");
    static_assert(sizeof(int) >= 2);            // C23: the message is optional

    printf("%d %d\n", (int)ready, (int)done);
    return 0;
}

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

static void takes_pointer(void *p)
{
    printf("%s\n", p == nullptr ? "null" : "not null");
}

int main(void)
{
    int *p = nullptr;               // type nullptr_t, converts to any pointer type
    takes_pointer(nullptr);
    takes_pointer(&p);

    // Why it matters: NULL may expand to plain 0, so in a VARIADIC call it can
    // pass an int where a pointer is expected. nullptr always passes a pointer.
    printf("%d\n", p == NULL);
    return 0;
}

#include <stdio.h>

constexpr int MAX_ITEMS = 64;                   // typed, scoped, a constant expression
constexpr double TAU = 6.283185307179586;
constexpr unsigned char MASK = 0xF0;

int main(void)
{
    int items[MAX_ITEMS];                       // not a VLA -- a real constant
    printf("%zu %g %u\n", sizeof items / sizeof items[0], TAU, MASK);
    return 0;
}

#include <stdio.h>

int main(void)
{
    int value = 42;

    typeof(value) same_type = value;            // int
    typeof(&value) pointer = &value;            // int *

    const int frozen = 7;
    typeof_unqual(frozen) writable = frozen;    // int, const stripped
    writable = 8;

    auto inferred = 3.5;                        // double, from the initializer
    auto text = "hello";                        // char *

    printf("%d %d %d %g %s\n", same_type, *pointer, writable, inferred, text);
    return 0;
}

#include <limits.h>
#include <stdio.h>

int main(void)
{
    _BitInt(12) twelve_bits = 2047;
    unsigned _BitInt(3) three_bits = 7;
    _BitInt(128) very_wide = 170141183460469231731687303715884105727wb;

    printf("%d %u %d (max width %d)\n",
           (int)twelve_bits, (unsigned)three_bits,
           (int)(very_wide >> 120), (int)BITINT_MAXWIDTH);
    return 0;
}

#include <stdio.h>

struct Config { int a; int b; char name[8]; };

int main(void)
{
    int binary = 0b1010'1010;               // binary literal + digit separators
    long long big = 1'000'000'000'000LL;
    unsigned char byte = 0b1111'0000;

    struct Config empty = { };              // empty initializer: everything zeroed
    int zeros[4] = { };

    printf("%d %lld %u %d %d\n", binary, big, byte, empty.a, zeros[3]);
    return 0;
}

#include <stdio.h>

[[nodiscard("the status must be checked")]] static int operation(void)
{
    return 0;
}

// External linkage and defined below, so it is not referenced here -- calling it
// is what produces "warning: 'old_operation' is deprecated: use operation() instead".
[[deprecated("use operation() instead")]] int old_operation(void);

int old_operation(void)
{
    return 1;
}

static int classify(int value, [[maybe_unused]] int debug)
{
    switch (value) {
    case 1:
        [[fallthrough]];
    case 2:
        return 10;
    default:
        return 0;
    }
}

int main(void)
{
    // __has_c_attribute lets a header probe before using one:
#if defined(__has_c_attribute) && __has_c_attribute(nodiscard)
    puts("nodiscard is available");
#endif

    printf("%d %d\n", operation(), classify(1, 0));
    return 0;
}

#include <stdio.h>

// __VA_OPT__ makes a zero-argument variadic macro standard:
#define LOG(format, ...) printf("[log] " format "\n" __VA_OPT__(,) __VA_ARGS__)

int main(void)
{
    LOG("no arguments");                // works in C23, was a GNU extension before
    LOG("value = %d", 42);

    // #elifdef / #elifndef shorthands:
#if 0
    puts("never");
#elifdef __STDC_VERSION__
    puts("elifdef works");
#endif

    // __has_include, standardized:
#if defined(__has_include) && __has_include(<stdbit.h>)
    puts("<stdbit.h> is present");
#endif
    return 0;
}