Causes the remaining portion of the enclosing for, range-for, while or do-while loop body skipped. Used when it is otherwise awkward to ignore the remaining portion of the loop using conditional statements. Syntax attr(optional) continue ; Explanation The continue statement causes a jump, as if by goto to the end of the loop body (it may only appear within the loop body of for, range-for, while, and do-while loops). More precisely, For while loop, it acts as. while (/* ... */) {

Defined in header <locale> public: const CharT* scan_is( mask m, const CharT* beg, const CharT* end ) const; (1) protected: virtual const CharT* do_scan_is( mask m, const CharT* beg, const CharT* end) const; (2) 1) public member function, calls the protected virtual member function do_scan_is of the most derived class. 2) Locates the first character in the character array [beg, end) that satisfies the classification mask m, that is, the first character c such that i

template< class Clock, class Duration > bool try_lock_shared_until( const std::chrono::time_point<Clock,Duration>& timeout_time ); (since C++14) Tries to lock the mutex in shared mode. Blocks until specified timeout_time has been reached or the lock is acquired, whichever comes first. On successful lock acquisition returns true, otherwise returns false. If timeout_time has already passed, this function behaves like try_lock_shared(). The clock tied to timeout_time is use

template< class T > complex<T> operator+( const complex<T>& lhs, const complex<T>& rhs); (1) template< class T > complex<T> operator+( const complex<T>& lhs, const T& rhs); (2) template< class T > complex<T> operator+( const T& lhs, const complex<T>& rhs); (3) template< class T > complex<T> operator-( const complex<T>& lhs, const complex<T>& rhs); (4) temp

Defined in header <complex> template< class T > complex<T> cos( const complex<T>& z ); Computes complex cosine of a complex value z. Parameters z - complex value Return value If no errors occur, the complex cosine of z is returned. Errors and special cases are handled as if the operation is implemented by std::cosh(i*z), where i is the imaginary unit. Notes The cosine is an entire function on the complex plane, and has no branch cuts.

Defined in header <ratio> template< class R1, class R2 > using ratio_divide = /* see below */; The alias template std::ratio_divide denotes the result of dividing two exact rational fractions represented by the std::ratio specializations R1 and R2. The result is a std::ratio specialization std::ratio<U, V>, such that given Num == R1::num * R2::den and Denom == R1::den * R2::num (computed without arithmetic overflow), U is std::ratio<Num, Denom>::num and V

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

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

Defined in header <ratio> template< class R1, class R2 > using ratio_subtract = /* see below */; The alias template std::ratio_subtract denotes the result of subtracting two exact rational fractions represented by the std::ratio specializations R1 and R2. The result is a std::ratio specialization std::ratio<U, V>, such that given Num == R1::num * R2::den - R2::num * R1::den and Denom == R1::den * R2::den (computed without arithmetic overflow), U is std::ratio<

basic_string& assign( size_type count, CharT ch ); (1) basic_string& assign( const basic_string& str ); (2) (3) basic_string& assign( const basic_string& str, size_type pos, size_type count ); (until C++14) basic_string& assign( const basic_string& str, size_type pos, size_type count = npos); (since C++14) basic_string& assign( basic_string&& s