static const int radix; (until C++11) static constexpr int radix; (since C++11) The value of std::numeric_limits<T>::radix is the base of the number system used in the representation of the type. It is 2 for all binary numeric types, but it may be, for example, 10 for IEEE 754 decimal floating-point types or for third-party binary-coded decimal integers. This constant is meaningful for all specializations. Standard specializations T value of std::numeric_limits<T>

protected: virtual streambuf<char>* setbuf(char* s, std::streamsize n); If s is a null pointer and n is zero, this function has no effect. Otherwise, the effect is implementation-defined: some implementations do nothing, while some implementations deallocate the dynamic member array used as the buffer and begin using the user-supplied character array of size n, whose first element is pointed to by s. This function is protected virtual, it may only be called through pubsetbuf() or

Defined in header <cfenv> int feclearexcept( int excepts ); (since C++11) Attempts to clear the floating-point exceptions that are listed in the bitmask argument excepts, which is a bitwise OR of the floating point exception macros. Parameters excepts - bitmask listing the exception flags to clear Return value ​0​ if all indicated exceptions were successfully cleared or if excepts is zero. Returns a non-zero value on error. Example #include <iostream&g

void swap( list& other ); Exchanges the contents of the container with those of other. Does not invoke any move, copy, or swap operations on individual elements. All iterators and references remain valid. It is unspecified whether an iterator holding the past-the-end value in this container will refer to the this or the other container after the operation. If std::allocator_traits<allocator_type>::propagate_on_container_swap::value is true, then the allocators are exchanged u

Defined in header <atomic> atomic_flag(); (1) (since C++11) atomic_flag( const atomic_flag& ) = delete; (2) (since C++11) Constructs a new std::atomic_flag. 1) Trivial default constructor, initializes std::atomic_flag to unspecified state. 2) The copy constructor is deleted; std::atomic_flag is not copyable. In addition, std::atomic_flag can be value-initialized to clear state with the expression ATOMIC_FLAG_INIT. For an atomic_flag with static storage duration, t

Defined in header <functional> template< class T > struct modulus; (until C++14) template< class T = void > struct modulus; (since C++14) Function object for computing remainders of divisions. Implements operator% for type T. Specializations The standard library provides a specialization of std::modulus when T is not specified, which leaves the parameter types and return type to be deduced. modulus<void> function object implementing x % y ded

template< class CharT, class Traits, class ResultType > std::basic_ostream<CharT,Traits>& operator<<( std::basic_ostream<CharT,Traits>& ost, const exponential_distribution<ResultType>& d ); (1) template< class CharT, class Traits, class ResultType > std::basic_istream<CharT,Traits>& operator>>( std::basic_istream<CharT,Traits>& ist,

(since C++11) bool is_lock_free() const; bool is_lock_free() const volatile; Checks whether the atomic operations on all objects of this type are lock-free. Parameters (none). Return value true if the atomic operations on the objects of this type are lock-free, false otherwise. Exceptions noexcept specification: noexcept See also atomic_is_lock_free (C++11) checks if the atomic type's operations are lock-free (function template)

template< class Deleter, class T > Deleter* get_deleter( const std::shared_ptr<T>& p ); (since C++11) Access to the p's deleter. If the shared pointer p owns a deleter of type cv-unqualified Deleter (e.g. if it was created with one of the constructors that take a deleter as a parameter), then returns a pointer to the deleter. Otherwise, returns a null pointer. Parameters p - a shared pointer whose deleter needs to be accessed Return value A pointer to the o

size_type size() const; (since {std}) Returns the number of elements in the container, i.e. std::distance(begin(), end()). Parameters (none). Return value The number of elements in the container. Exceptions noexcept specification: noexcept Complexity Constant. Example Template:cpp/container/dynarray/example size See also empty checks whether the container is empty (public member function) max_size returns the maximum possible number of elements (public me