Defined in header <functional> template< class R, class T > /*unspecified*/ mem_fn(R T::* pm); (1) (since C++11) template< class R, class T, class... Args > /*unspecified*/ mem_fn(R (T::* pm)(Args...)); template< class R, class T, class... Args > /*unspecified*/ mem_fn(R (T::* pm)(Args...) const); template< class R, class T, class... Args > /*unspecified*/ mem_fn(R (T::* pm)(Args...) volatile); template< class R, class T, class... Args > /*un

Defined in header <cstring> void* memset( void* dest, int ch, std::size_t count ); Converts the value ch to unsigned char and copies it into each of the first count characters of the object pointed to by dest. If the object is not trivially-copyable (e.g., scalar, array, or a C-compatible struct), the behavior is undefined. If count is greater than the size of the object pointed to by dest, the behavior is undefined. Parameters dest - pointer to the object to fill

Defined in header <atomic> enum memory_order { memory_order_relaxed, memory_order_consume, memory_order_acquire, memory_order_release, memory_order_acq_rel, memory_order_seq_cst }; (since C++11) std::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 t

Defined in header <cstring> void* memmove( void* dest, const void* src, std::size_t count ); Copies count characters from the object pointed to by src to the object pointed to by dest. Both objects are reinterpreted 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 characters were copied from the array to dest. If the objects are not TriviallyCopyable, the behavior of memmove

Defined in header <cstring> void* memcpy( void* dest, const void* src, std::size_t count ); Copies count bytes from the object pointed to by src to the object pointed to by dest. Both objects are reinterpreted as arrays of unsigned char. If the objects overlap, the behavior is undefined. If either dest or src is a null pointer, the behavior is undefined, even if count is zero. If the objects are not TriviallyCopyable, the behavior of memcpy is not specified and may be undef

Defined in header <cstring> int memcmp( const void* lhs, const void* rhs, std::size_t count ); Reinterprets the objects pointed to by lhs and rhs as arrays of unsigned char and compares the first count characters of these arrays. 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. Parameters lhs, rhs -

Defined in header <cstring> const void* memchr( const void* ptr, int ch, std::size_t count ); void* memchr( void* ptr, int ch, std::size_t count ); Converts ch to unsigned char and locates the first occurrence of that value in the initial count characters (each interpreted as unsigned char) of the object pointed to by ptr. Parameters ptr - pointer to the object to be examined ch - character to search for count - number of characters to

Defined in header <cstdlib> int mbtowc( wchar_t* pwc, const char* s, std::size_t n ); Converts a multibyte character whose first byte is pointed to by s to a wide character, written to *pwc if pwc is not null. If s is a null pointer, resets the global conversion state and determines whether shift sequences are used. Parameters s - pointer to the multibyte character n - limit on the number of bytes in s that can be examined pwc - pointer to the wide chara

Defined in header <cstdlib> std::size_t mbstowcs( wchar_t* dst, const char* src, std::size_t len); Converts a multibyte character string from the array whose first element is pointed to by src to its wide character representation. Converted characters are stored in the successive elements of the array pointed to by dst. No more than len wide characters are written to the destination array. Each character is converted as if by a call to std::mbtowc, except that the mbtowc co

Defined in header <cwchar> struct mbstate_t; The type mbstate_t is a trivial non-array type that can represent any of the conversion states that can occur in an implementation-defined set of supported multibyte character encoding rules. Zero-initialized value of mbstate_t represents the initial conversion state, although other values of mbstate_t may exist that also represent the initial conversion state. Possible implementation of mbstate_t is a struct type holding an arra