Defined in header <complex> template< class T > complex<T> cosh( const complex<T>& z ); (since C++11) Computes complex hyperbolic cosine of a complex value z. Parameters z - complex value Return value If no errors occur, complex hyperbolic cosine of z is returned. Error handling and special values Errors are reported consistent with math_errhandling. If the implementation supports IEEE floating-point arithmetic, std::cosh(std::conj(z

bool empty() const; (since C++11) Checks if the container has no elements, i.e. whether begin() == end(). Parameters (none). Return value true if the container is empty, false otherwise. Exceptions noexcept specification: noexcept Complexity Constant. Example The following code uses empty to check if a std::unordered_map<int,int> contains any elements: #include <unordered_map> #include <iostream> #include <utility> int main() { std::unorde

The Clock concept describes a bundle consisting of a std::chrono::duration, a std::chrono::time_point, and a function now() to get the current time_point. The origin of the clock's time_point is referred to as the clock's epoch. Requirements C1 and C2 denote clock types. t1 and t2 are values returned by C1::now() where the call returning t1 happens before the call returning t2 and both of these calls occur before C1::time_point::max(). Expression Return type Operational semantics C1::rep

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

template< class ResultType > bool operator==( const piecewise_constant_distribution<ResultType>& lhs, const piecewise_constant_distribution<ResultType>& rhs ); (1) template< class ResultType > bool operator!=( const piecewise_constant_distribution<ResultType>& lhs, const piecewise_constant_distribution<ResultType>& rhs ); (2) Compares two distribution objects. Two distribution objects are equal w

Defined in header <algorithm> template< class InputIt1, class InputIt2, class OutputIt > OutputIt set_union( InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt d_first ); (1) template< class InputIt1, class InputIt2, class OutputIt, class Compare > OutputIt set_union( InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt d_first,

Usage continue statement: as the declaration of the statement

Defined in header <random> template< class UIntType, size_t w, size_t s, size_t r > class subtract_with_carry_engine; (since C++11) subtract_with_carry_engine is a random number engine that uses subtract with carry algorithm. The following typedefs define the random number engine with two commonly used parameter sets: Defined in header <random> Type Definition ranlux24_base std::subtract_with_carry_engine<std::uint_fast32_t, 24, 10, 24>

reference back(); const_reference back() const; Returns reference to the last element in the queue. This is the most recently pushed element. Effectively calls c.back(). Parameters (none). Return value reference to the last element. Complexity Constant. See also front access the first element (public member function) push inserts element at the end (public member function)

template< class... Args > void emplace( Args&&... args ); (since C++11) Pushes new element to the end of the queue. The element is constructed in-place, i.e. no copy or move operations are performed. The constructor of the element is called with exactly the same arguments as supplied to the function. Effectively calls c.emplace_back(std::forward<Args>(args)...). Parameters args - arguments to forward to the constructor of the element Return value (none)