Defined in header <stdlib.h> int atoi( const char *str ); long atol( const char *str ); long long atoll( const char *str ); (since C99) Interprets an integer value in a byte string pointed to by str. Discards any whitespace characters until the first non-whitespace character is found, then takes as many characters as possible to form a valid integer number representation and converts them to an integer value. The valid integer value consists of the fo

Defined in header <stdlib.h> int atexit( void (*func)() ); Registers the function pointed to by func to be called on normal program termination (via exit() or returning from main()). The functions will be called in reverse order they were registered, i.e. the function registered last will be executed first. The same function may be registered more than once. atexit is thread-safe: calling the function from several threads does not induce a data race. The implementation is g

Defined in header <math.h> #define isgreater(x, y) /* implementation defined */ (since C99) Determines if the floating point number x is greater than the floating-point number (y), without setting floating-point exceptions. Parameters x - floating point value y - floating point value Return value Nonzero integral value if x > y, ​0​ otherwise. Notes The built-in operator> for floating-point numbers may set FE_INVALID if one or both of the argume

Defined in header <math.h> #define islessgreater(x, y) /* implementation defined */ (since C99) Determines if the floating point number x is less than or greater than the floating-point number y, without setting floating-point exceptions. Parameters x - floating point value y - floating point value Return value Nonzero integral value if x < y || x > y, ​0​ otherwise. Notes The built-in operator< and operator> for floating-point numbers may

Defined in header <math.h> #define HUGE_VALF /*implementation defined*/ (since C99) #define HUGE_VAL /*implementation defined*/ #define HUGE_VALL /*implementation defined*/ (since C99) The HUGE_VALF, HUGE_VAL and HUGE_VALL macros expand to positive floating point constant expressions which compare equal to the values returned by floating-point functions and operators in case of overflow (see math_errhandling). Constant Explanation HUGE_VALF Expands to po

Defined in header <stdatomic.h> _Bool atomic_is_lock_free( const volatile A* obj ); (since C11) Determines if the atomic operations on all objects of the type A (the type of the object pointed to by obj) are lock-free. In any given program execution, the result of calling atomic_is_lock_free is the same for all pointers of the same type. This is a generic function defined for all atomic object types A. The argument is pointer to a volatile atomic type to accept addresses of

Defined in header <stdatomic.h> _Bool atomic_flag_test_and_set( volatile atomic_flag* obj ); (1) (since C11) _Bool atomic_flag_test_and_set_explicit( volatile atomic_flag* obj, memory_order order ); (2) (since C11) Atomically changes the state of a atomic_flag pointed to by obj to set (true) and returns the previous value. The first version orders memory accesses according to memory_order_seq_cst, the second version orders memory accesses according to order. The argum

An object whose identifier is declared with the storage-class specifier _Thread_local (since C11) has thread storage duration. Its lifetime is the entire execution of the thread for which it is created, and its stored value is initialized when the thread is started. There is a distinct object per thread, and use of the declared name in an expression refers to the object associated with the thread evaluating the expression. The result of attempting to indirectly access an object with thread stor

Defined in header <time.h> double difftime( time_t time_end, time_t time_beg ); Computes difference between two calendar times as time_t objects (time_end - time_beg) in seconds. If time_end refers to time point before time_beg then the result is negative. Parameters time_beg, time_end - times to compare Return value Difference between two times in seconds. Notes On POSIX systems, time_t is measured in seconds, and difftime is equivalent to arithmetic subtr

Defined in header <time.h> typedef /* unspecified */ clock_t; Arithmetic (until C11)Real (since C11) type capable of representing the processor time used by a process. It has implementation-defined range and precision. References C11 standard (ISO/IEC 9899:2011): 7.27.1/3 Components of time (p: 388) C99 standard (ISO/IEC 9899:1999): 7.23.1/3 Components of time (p: 338) C89/C90 standard (ISO/IEC 9899:1990): 4.12.1 Components of time See also clock return