| 9 8 7 6 5 4 3 2 1 0 1 2 3 4 5 6 7 8 99 8 7 6 5 4 3 2 1 0 1 2 3 4 5 6 7 8 9 |

                                 C99 CHANGELOG
                                  2026-03-11

                          /$$$$$$   /$$$$$$   /$$$$$$
                         /$$__  $$ /$$__  $$ /$$__  $$
                        | $$  \__/| $$  \ $$| $$  \ $$
                        | $$      |  $$$$$$$|  $$$$$$$
                        | $$       \____  $$ \____  $$
                        | $$    $$ /$$  \ $$ /$$  \ $$
                        |  $$$$$$/|  $$$$$$/|  $$$$$$/
                         \______/  \______/  \______/

..............................................................................

  This is just a small summary of the most notable and interesting language
  features that were added with C99 along with small explanations and
  examples. 

  + Single Line Comments 
------------------------------------------------------------------------------
  Comments may be quoted with //. 

    // this comment ends at the end of this line

  + Long Long Type 
------------------------------------------------------------------------------
  There is now a long long int type. 

    long long x = 42;

  + Designated Initialisers 
------------------------------------------------------------------------------
  This allows you to specify fields/indices during initialisation directly. 

    struct foo bar = {.x=42, .y=1};
    int baz[4] = { [2] = 3, [1] = 6 };

  All unspecified fields/indices are set to zero. 

  + Compound Literals 
------------------------------------------------------------------------------
  Allows the following syntax: 

    (type){initializer list}

  This allows for example arrays and structs to be represented as literals: 

    (const float []){1e0, 1e1, 1e2}
    (struct point){.x=1, .y=1}

  + Variable Length Arrays 
------------------------------------------------------------------------------
  Arrays can now be declared with variables inside array subscript
  operators. 

    int n = 1;
    char arr[n];

  It is also possible to write an unspecified VLA size as: 

    void foo(int a[*]);

  This is only allowed in prototypes. 

  + Flexible Array Members 
------------------------------------------------------------------------------
  Array members inside structs are allowed to have no size. 

    typedef struct {
      size_t len;
      double arr[]; // Flexible array member
    } DUMMY;

  + Init in For-Loop 
------------------------------------------------------------------------------
  It is now allowed to initialise the counter variable inside the for
  statement. 

    for (int i = 0; i < 100; i++) {}

  + Implicit Return in Main 
------------------------------------------------------------------------------
  The return inside of the main entry point can by omitted. 

    int main(void)
    {
      // no return
    }

  + Hex Float Literals 
------------------------------------------------------------------------------
  Floating point literals can by denoted in hex using the 0x prefix. 

    double d = 0x1.2p3;

  + Variadic Macros 
------------------------------------------------------------------------------
  It's now possible to use a variable number of arguments for macros using
  __VA_ARGS__. 

    #define eprintf(format, ...) fprintf (stderr, format, __VA_ARGS__)

  + Mixed Declarations and Statements 
------------------------------------------------------------------------------
  It isn't necessary anymore to have declarations come before other
  statements. 

    int x = 42;
    func();
    int y = 1;

  + Unicode in Identifier 
------------------------------------------------------------------------------
  Unicode characters are now allowed in identifiers. 

  + Restrict Pointers 
------------------------------------------------------------------------------
  A new keyword which tells the compiler a pointer is unique, i.e. in the
  block only this pointer should read/write to the reference. 

    int* restrict p1 = &a;
    int* restrict p2 = &b;
    p1 = p2; // undefined behavior

  + Inline Functions 
------------------------------------------------------------------------------
  A hint for the compiler to do function inlining, i.e. replace a function
  call with it's body. 

    static int x;

    inline void f(void)
    {
      // error: non-const static in non-static inline function
      static int n = 1;

      // error: non-static inline function accesses static variable
      int k = x;
    }

  + Function Name Macro 
------------------------------------------------------------------------------
  Inside every function there is now a predefined macro __func__, which
  stores the functions name. 

    void foo(void)
    {
      puts(__func__); // prints foo
    }

..............................................................................

LINKS:

  There are more changes then listed here so go ahead and take a look:
  https://cppreference.com/w/c/99.html