1. IEEE-754 floating-point arithmetic
2. complex number
3. variable length arrays (VLAs)
4. type generic mathematical functions for polymorphism
5. long long and unsigned long long
6. mixing declarations and code
7. binary integral constants
8. predefined identifier __func__
9. the variable argument list macro
10. hexadecimal floating-point constants
11. // comments
12. the header file complex.h
13. the header file fenv.h
14. the header file inttypes.h
15. the header file iso646.h
16. the header file stdbool.h
17. the header file stdin.h
18. the header file tgmath.h
19. the header file wchar.h
20. the header file wctype.h
21. new translation limits
22. va_copy() in header file stdarg.h
23. keywords restrict and inline
24. remove implicit int

#include <stdio.h>
#include <math.h>

int main() {
    printf("1/0.0 = %f\n", 1/0.0);
    printf("-1/0.0 = %f\n", -1/0.0);
    printf("0.0/0.0 = %f\n", 0.0/0.0);
    printf("sqrt(-1.0) = %f\n", sqrt(-1.0));
    printf("INFINITY/INFINITY = %f\n", INFINITY/INFINITY);
}

complex number

/* complex in C99 is a built-in data type.
   complex in C++ is a class. They are not compatible.
   A program using complex conforming either C99 or C++ can readily run
   in Ch without modification. */
        
#include <stdio.h> 
#include <complex.h>
        
int main() {
    double complex z1 = 1+I*2;                // C99 and Ch
    double_complex z2 = double_complex(1, 2); // C++ and Ch
    double complex z3 = complex(1, 2);        // Ch
    double complex sz1, sz2, sz3;
          
    sz1 = csqrt(z1);                              // C99 and Ch
    sz2 = sqrt(z2);                               // C++ and Ch
    sz3 = sqrt(z3);                               // C++ and Ch
    printf("sz1 = %f, %f\n", creal(sz1), cimag(sz1)); // C99 and Ch
    printf("sz2 = %f, %f\n", real(sz2),  imag(sz2));  // C++ and Ch
    printf("sz3 = %f\n", sz3);                 // Ch, added for users's convenience
                       
}

variable length arrays (VLAs)

Example 1:

   
#include <stdio.h>
        
void func(int n, int m, int a[n][m]);
void func(int n, int m, int a[*][*]);

void func(int n, int m, int a[n][m]) { // a is VLA 
    int b[n][m], c[n]; /* b and c are VLAs */

    printf("sizeof(b) = %d\n", sizeof(b));
    printf("sizeof(c) = %d\n", sizeof(c));
    printf("a[1][2] in func() = %d\n", a[1][2]);
    a[1][2] = 100;
}       
          
int main() {
    int a1[2][3] = {1,2,3,
                          4,5,6};
    int a2[3][4] = {1,2,3,4,
                          5,6,7,8,
                          9,10,11,12};
    func(2, 3, a1);
    printf("a1[1][2] in main() = %d\n", a1[1][2]);
    func(3, 4, a2);
    printf("a2[1][2] in main() = %d\n", a2[1][2]);
    return 0;
}

Example 2:

#include <stdio.h>
#include <chplot.h>

int main() {
     int n;
     scanf("%d", &n);
     double x[n], y[n];
     ...
     plotxy(x, y, n, "title", "x", "y");
     return 0;
}

type generic mathematical functions for polymorphism

   
#include <stdio.h>
#include <tgmath.h>
#include <complex.h>
int main() {
    int i=3;
    float fi, f=3;
    double d=3;
    complex z=3;
    double complex dz=3;
    fi = sin(i);
    f = sin(f);
    d = sin(d);
    z = sin(z);
    dz = sin(dz);
    printf("fi = %f\n", fi);
    printf("f = %f\n", f);
    printf("d = %f\n", d);
    printf("z = %f\n", z);
    printf("dz = %f\n", dz);
}       

long long and unsigned long long

#include <stdio.h>

int main () {
   unsigned long long u;
   long long l;

   u = 20ULL;
   l = 20LL;
   printf("u = %llu\n", u);               //  output: u = 20
   printf("l = %lld\n", l);               //  output: l = 20
   printf("sizeof(l) = %d\n", sizeof(l)); //  output: l = 8
   scanf("%lld", &l);                     //  type input of "22"
   printf("l = %lld\n", l);               //  output: l = 22
   return 0;
}

mixing declarations and code

int main() {
   int x, y;
   x = 3;
   y = 4;
   int xy = x*y;
   int a[xy];
}

binary integral constants

/* Binary I/O */
#include <stdio.h>
int main() {
  unsigned int address;
  unsigned char *p, mask = 0b00110101; // Binary integer

  p = (char *)&address; /* p can point to a hardware memory address */
  *p = mask;
  printf("*p = %d\n", *p);   // output decimal integer
  printf("p = %b\n", mask);  // output binary integer starting with 1
  printf("p = %8b\n", *p);   // output 8 bits of binary integer
}

/* output
*p = 53
p = 110101
p = 00110101
*/

predefined identifier __func__

#include <stdio.h>

void funct() {
    printf("Function %s() is called.\n", __func__);
}

int main () {
   funct();
}

/* output
    Function funct() is called.
*/

the variable argument list macro

    #define debug(...)    fprintf(stderr, __VA_ARGS__)
    debug("Flag");
    debug("x = %d\n", x);
    #define showlist(...) puts(#__VA_ARGS__)
    #define report(test, ...) ((test)?puts(#test):\
                       printf(__VA_ARGS__))

    fprintf(stderr,  "Flag" );
    fprintf(stderr,  "x = %d\n", x );
    puts( "The first, second, and third items." );
    ((x>y)?puts("x>y"):
              printf("x is %d but y is %d", x, y));

hexadecimal floating-point constants

       > 0X2P3
       16.0000
       > 0x1.1p0
       1.0625
       > 0x1.1p1F
       2.12