void swap( basic_istringstream& other ); (since C++11) Exchanges the state of the stream with those of other. This is done by callingbasic_istream<CharT, Traits>::swap(other) and rdbuf()->swap(*other.rdbuf()). Parameters other - stream to exchange the state with Return value (none). Example See also operator= (C++11) moves the string stream (public member function) swap (C++11) swaps two basic_stringbuf objects (public member function of st

bool try_lock(); (since C++14) Tries to lock the associated mutex in shared mode without blocking. Effectively calls mutex()->try_lock_shared(). std::system_error is thrown if there is no associated mutex or if the mutex is already locked. Parameters (none). Return value true if the ownership of the mutex has been acquired successfully, false otherwise. Exceptions Any exceptions thrown by mutex()->try_lock_shared() If there is no associated mutex, std::system_error wit

template< class CharT, class Traits, class ResultType > std::basic_ostream<CharT,Traits>& operator<<( std::basic_ostream<CharT,Traits>& ost, const gamma_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 Rep, class Period > bool try_lock_for( const std::chrono::duration<Rep,Period>& timeout_duration ); (since C++14) Tries to lock the associated mutex in shared mode. Blocks until specified timeout_duration has elapsed or the lock is acquired, whichever comes first. On successful lock acquisition returns true, otherwise returns false. Effectively calls mutex()->try_lock_shared_for(timeout_duration). A steady clock is used to measure the duration. This fu

template< class Clock, class Duration > bool try_lock_until( const std::chrono::time_point<Clock,Duration>& timeout_time ); (since C++14) Tries to lock the associated 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. May block for longer than until timeout_time has been reached. Effectively calls mutex()->try_lock_shared_until(

Defined in header <cctype> int toupper( int ch ); Converts the given character to uppercase according to the character conversion rules defined by the currently installed C locale. In the default "C" locale, the following lowercase letters abcdefghijklmnopqrstuvwxyz are replaced with respective uppercase letters ABCDEFGHIJKLMNOPQRSTUVWXYZ. Parameters ch - character to be converted. If the value of ch is not representable as unsigned char and does not equal EOF, the

strstreambuf* rdbuf() const; Returns a pointer to the associated std::strstreambuf, casting away its constness (despite the const qualifier on the member function). Parameters (none). Return value Pointer to the associated std::strsteambuf, with constness cast away. Example #include <strstream> int main() { const std::ostrstream buf; std::strstreambuf* ptr = buf.rdbuf(); }

void unlock_shared(); (since C++14) Releases the mutex from shared ownership by the calling thread. . The mutex must be locked by the current thread of execution in shared mode, otherwise, the behavior is undefined. This operation synchronizes-with (as defined in std::memory_order) any subsequent lock() operation that obtains ownership of the same mutex. Parameters (none). Return value (none). Exceptions (none). Notes unlock_shared() is usually not called directly: std::shar

Defined in header <locale> public: std::string grouping() const; (1) protected: virtual std::string do_grouping() const; (2) 1) Public member function, calls the member function do_grouping of the most derived class. 2) Returns the pattern that determines the grouping of the digits in the monetary output, with the same exact meaning as std::numpunct::do_grouping Return value The object of type std::string holding the groups. The standard specializations of std::

Defined in header <type_traits> template< class T > struct is_union; (since C++11) Checks whether T is an union type. Provides the member constant value which is equal to true, if T is an union type . Otherwise, value is equal to false. Template parameters T - a type to check Helper variable template template< class T > constexpr bool is_union_v = is_union<T>::value; (since C++17) Inherited from std::integral_constant Member co