Defined in header <threads.h> int mtx_init( mtx_t* mutex, int type ); (since C11) Creates a new mutex object with type. The object pointed to by mutex is set to an identifier of the newly created mutex. type must have one of the following values: mtx_plain - a simple, non-recursive mutex is created. mtx_timed - a non-recursive mutex, that supports timeout, is created. mtx_plain | mtx_recursive - a recursive mutex is created. mtx_timed | mtx_recursive - a recursive mu

Defined in header <threads.h> void mtx_destroy( mtx_t *mutex ); (since C11) Destroys the mutex pointed to by mutex. If there are threads waiting on mutex, the behavior is undefined. Parameters mutex - pointer to the mutex to destroy Return value (none). References C11 standard (ISO/IEC 9899:2011): 7.26.4.1 The mtx_destroy function (p: 380)

Defined in header <math.h> float modff( float arg, float* iptr ); (1) (since C99) double modf( double arg, double* iptr ); (2) long double modfl( long double arg, long double* iptr ); (3) (since C99) 1-3) Decomposes given floating point value arg into integral and fractional parts, each having the same type and sign as arg. The integral part (in floating-point format) is stored in the object pointed to by iptr. Parameters arg - floating point

Defined in header <time.h> time_t mktime( struct tm *time ); Renormalizes local calendar time expressed as a struct tm object and also converts it to time since epoch as a time_t object. time->tm_wday and time->tm_yday are ignored. The values in time are not checked for being out of range. A negative value of time->tm_isdst causes mktime to attempt to determine if Daylight Saving Time was in effect in the specified time. If the conversion to time_t is successful, t

Defined in header <string.h> void *memset( void *dest, int ch, size_t count ); (1) errno_t memset_s( void *dest, rsize_t destsz, int ch, rsize_t count ) (2) (since C11) 1) Copies the value ch (after conversion to unsigned char as if by (unsigned char)ch) into each of the first count characters of the object pointed to by dest. The behavior is undefined if access occurs beyond the end of the dest array. The behavior is undefined if dest is a null pointer. 2) Same a

Defined in header <stdatomic.h> enum memory_order { memory_order_relaxed, memory_order_consume, memory_order_acquire, memory_order_release, memory_order_acq_rel, memory_order_seq_cst }; (since C11) memory_order specifies how regular, non-atomic memory accesses are to be ordered around an atomic operation. Absent any constraints on a multi-core system, when multiple threads simultaneously read and write to several variables, one thread can observe the

Defines the semantics of computer memory storage for the purpose of the C abstract machine. The data storage (memory) available to a C program is one or more contiguous sequences of bytes. Each byte in memory has a unique address. Byte A byte is the smallest addressable unit of memory. It is defined as a contiguous sequence of bits, large enough to hold any member of the basic execution character set (the 96 characters that are required to be single-byte). C supports bytes of sizes 8 bits an

Defined in header <string.h> void* memmove( void* dest, const void* src, size_t count ); (1) errno_t memmove_s(void *dest, rsize_t destsz, const void *src, rsize_t count); (2) (since C11) 1) Copies count characters from the object pointed to by src to the object pointed to by dest. Both objects are interpreted as arrays of unsigned char. The objects may overlap: copying takes place as if the characters were copied to a temporary character array and then the character

Defined in header <string.h> (1) void* memcpy( void *dest, const void *src, size_t count ); (until C99) void* memcpy( void *restrict dest, const void *restrict src, size_t count ); (since C99) errno_t memcpy_s( void *restrict dest, rsize_t destsz, const void *restrict src, rsize_t count ); (2) (since C11) 1) Copies count characters from the object pointed to by src to the object pointed to by dest. Both objects are interpreted as arrays of uns

Defined in header <string.h> int memcmp( const void* lhs, const void* rhs, size_t count ); Compares the first count characters of the objects pointed to by lhs and rhs. The comparison is done lexicographically. The sign of the result is the sign of the difference between the values of the first pair of bytes (both interpreted as unsigned char) that differ in the objects being compared. The behavior is undefined if access occurs beyond the end of either object pointed to by