valarray<T> apply( T func(T) ) const; valarray<T> apply( T func(const T&) ) const; Returns a new valarray of the same size with values which are acquired by applying function func to the previous values of the elements. Parameters func - function to apply to the values Return value The resulting valarray with values acquired by applying function func. Notes The function can be implemented with the return type different from std::valarray. In this c

Defined in header <type_traits> template< class Base, class Derived > struct is_base_of; (since C++11) If Derived is derived from Base or if both are the same non-union class, provides the member constant value equal to true. Otherwise value is false. If both Base and Derived are non-union class types, and they are not the same type (ignoring cv-qualification), Derived shall be a complete type; otherwise the behavior is undefined. Helper variable template templa

Defined in header <valarray> template< class T > class slice_array; std::slice_array is a helper template used by std::slice subscript operator. It has reference semantics to a subset of the array specified by the std::slice object. Member types Type Definition value_type T Member functions (constructor) constructs a slice_array (public member function) (destructor) destroys a slice_array (public member function) operator= assigns conte

Defined in header <algorithm> template< class OutputIt, class Size, class T > void fill_n( OutputIt first, Size count, const T& value ); (until C++11) template< class OutputIt, class Size, class T > OutputIt fill_n( OutputIt first, Size count, const T& value ); (since C++11) Assigns the given value to the first count elements in the range beginning at first if count > 0. Does nothing otherwise. Parameters first - the beginning of the ran

template< class T, class Alloc > bool operator==( const forward_list<T,Alloc>& lhs, const forward_list<T,Alloc>& rhs ); (1) template< class T, class Alloc > bool operator!=( const forward_list<T,Alloc>& lhs, const forward_list<T,Alloc>& rhs ); (2) template< class T, class Alloc > bool operator<( const forward_list<T,Alloc>& lhs, const forward_list<T,Alloc>&

iterator before_begin(); (since C++11) const_iterator before_begin() const; (since C++11) const_iterator cbefore_begin() const; (since C++11) Returns an iterator to the element before the first element of the container. This element acts as a placeholder, attempting to access it results in undefined behavior. The only usage cases are in functions insert_after(), emplace_after(), erase_after(), splice_after() and the increment operator: incrementing the before-begin iterator

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

Specifies that an instance of the type can be destructed. Requirements The type T satisfies Destructible if. Given. u, a expression of type T The following expressions must be valid and have their specified effects. Expression Post-conditions u.~T() All resources owned by u are reclaimed, no exceptions are thrown. Notes Destructors are called implicitly at the end of object lifetime such as when leaving scope or by the delete-expression. Explicit destructor call as shown in the

Defined in header <typeindex> template<> struct hash<type_index>; (since C++11) The template specialization of std::hash for std::type_index allows users to obtain hashes of objects of type std::type_index. The member operator() effectively returns the same value as hash_code(). See also hash_code returns hashed code (public member function)

Defined in header <ratio> template< class R1, class R2 > struct ratio_equal : std::integral_constant; If the ratios R1 and R2 are equal, provides the member constant value equal true. Otherwise, value is false. Helper variable template template< class R1, class R2 > constexpr bool ratio_equal_v = ratio_equal<R1, R2>::value; (since C++17) Inherited from std::integral_constant Member constants value [static] true if R1::num == R2::num