nearbyint

Defined in header <math.h> float nearbyintf( float arg ); (1) (since C99) double nearbyint( double arg ); (2) (since C99) long double nearbyintl( long double arg ); (3) (since C99) Defined in header <tgmath.h> #define nearbyint( arg ) (4) (since C99) 1-3) Rounds the floating-point argument arg to an integer value in floating-point format, using the current rounding mode. 4) Type-generic macro: If arg has type long double, nearbyin

atan2

Defined in header <math.h> float atan2f( float y, float x ); (1) (since C99) double atan2( double y, double x ); (2) long double atan2l( long double y, long double x ); (3) (since C99) Defined in header <tgmath.h> #define atan2( arg ) (4) (since C99) 1-3) Computes the arc tangent of y/x using the signs of arguments to determine the correct quadrant. 4) Type-generic macro: If the argument has type long double, atan2l is called. Oth

Implicit conversions

When an expression is used in the context where a value of a different type is expected, conversion may occur: int n = 1L; // expression 1L has type long, int is expected n = 2.1; // expression 2.1 has type double, int is expected char *p = malloc(10); // expression malloc(10) has type void*, char* is expected Conversions take place in the following situations: Conversion as if by assignment In the assignment operator, the value of the right-hand operand is converted to the unqualified type

wcstombs

Defined in header <stdlib.h> (1) size_t wcstombs( char *dst, const wchar_t *src, size_t len ); (until C99) size_t wcstombs( char *restrict dst, const wchar_t *restrict src, size_t len ); (since C99) errno_t wcstombs_s( size_t *restrict retval, char *restrict dst, rsize_t dstsz, const wchar_t *restrict src, rsize_t len ); (2) (since C11) 1) Converts a sequence of wide characters from the array whose first element is pointed

wcstof

Defined in header <wchar.h> float wcstof( const wchar_t* str, wchar_t** str_end ); (since C99) double wcstod( const wchar_t* str, wchar_t** str_end ); (since C95) long double wcstold( const wchar_t* str, wchar_t** str_end ); (since C99) Interprets a floating point value in a wide string pointed to by str. Function discards any whitespace characters (as determined by std::isspace()) until first non-whitespace character is found. Then it takes as many c

register

Usage automatic duration storage-class specifier with no linkage. Hints that the variable will be used heavily.

rand

Defined in header <stdlib.h> int rand(); Returns a pseudo-random integral value between ​0​ and RAND_MAX (0 and RAND_MAX included). srand() seeds the pseudo-random number generator used by rand(). If rand() is used before any calls to srand(), rand() behaves as if it was seeded with srand(1). Each time rand() is seeded with srand(), it must produce the same sequence of values. rand() is not guaranteed to be thread-safe. Parameters (none). Return value Pseudo-random in

Atomic operations library

If the macro constant __STDC_NO_ATOMICS__(C11) is defined by the compiler, the header <stdatomic.h>, the keyword _Atomic, and all of the names listed here are not provided. Types Defined in header <stdatomic.h> memory_order (C11) defines memory ordering constraints (enum) atomic_flag (C11) lock-free atomic boolean flag (struct) Macros Defined in header <stdatomic.h> ATOMIC_BOOL_LOCK_FREEATOMIC_CHAR_LOCK_FREEATOMIC_CHAR16_T_LOCK_FREEATOMIC_CHAR32_

ignore_handler_s

Defined in header <stdlib.h> void ignore_handler_s( const char * restrict msg, void * restrict ptr, errno_t error ); (since C11) The function simply returns to the caller without performing any other action. A pointer to this function can be passed to set_constraint_handler_s to establish a runtime constraints violation handler that does nothing. As with all bounds-checked functions, ignore_handler_s is onl

atomic_compare_exchange_weak

Defined in header <stdatomic.h> _Bool atomic_compare_exchange_strong( volatile A* obj, C* expected, C desired ); (1) (since C11) _Bool atomic_compare_exchange_weak( volatile A *obj, C* expected, C desired ); (2) (since C11) _Bool atomic_compare_exchange_strong_explicit( volatile A* obj, C* expected, C desired,