basic_regex& assign( const basic_regex& other ); (1) (since C++11) basic_regex& assign( basic_regex&& that ); (2) (since C++11) basic_regex& assign( const CharT* s, flag_type f = std::regex_constants::ECMAScript ); (3) (since C++11) basic_regex& assign( const charT* ptr, size_t count, flag_type f = std::regex_constants::ECMAScript ); (4) (since C++11) template< class ST, class SA > basic_regex&

Defined in header <regex> static constexpr std::regex_constants::syntax_option_type icase = std::regex_constants::icase; static constexpr std::regex_constants::syntax_option_type nosubs = std::regex_constants::nosubs; static constexpr std::regex_constants::syntax_option_type optimize = std::regex_constants::optimize; static constexpr std::regex_constants::syntax_option_type collate = std::regex_constants::collate; static constexpr std::regex_constants::syntax_optio

Defined in header <regex> template < class CharT, class Traits = std::regex_traits<CharT> > class basic_regex; (since C++11) The class template basic_regex provides a general framework for holding regular expressions. Several specializations for common character types are provided: Defined in header <regex> Type Definition regex basic_regex<char> wregex basic_regex<wchar_t> Member types Member type Definition va

explicit basic_ostringstream( ios_base::openmode mode = ios_base::out ); (1) explicit basic_ostringstream( const std::basic_string<CharT,Traits,Allocator>& str, ios_base::openmode mode = ios_base::out ); (2) basic_ostringstream( basic_ostringstream&& other ); (3) (since C++11) Constructs new string stream. 1) Constructs new underlying string device. The underlying basic_stringbuf object is constructed as basic_stringbuf<Char,Traits,A

void swap( basic_ostringstream& other ); (since C++11) Exchanges the state of the stream with those of other. This is done by callingbasic_ostream<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

std::basic_stringbuf<CharT, Traits, Allocator>* rdbuf() const; Returns pointer to the underlying raw string device object. Parameters (none). Return value Pointer to the underlying raw string device. Example

std::basic_string<CharT,Traits,Allocator> str() const; (1) void str(const std::basic_string<CharT,Traits,Allocator>& new_str); (2) Manages the contents of the underlying string object. 1) Returns a copy of the underlying string as if by calling rdbuf()->str(). 2) Replaces the contents of the underlying string as if by calling rdbuf()->str(new_str). Parameters new_str - new contents of the underlying string Return value 1) a copy of the underlyin

Defined in header <sstream> template< class CharT, class Traits = std::char_traits<CharT> > class basic_ostringstream; (until C++11) template< class CharT, class Traits = std::char_traits<CharT>, class Allocator = std::allocator<CharT> > class basic_ostringstream; (since C++11) The class template std::basic_ostringstream implements output operations on memory (std::basic_string) based streams. It essentially wraps

protected: void swap(basic_ostream& rhs); (since C++11) Calls basic_ios::swap(rhs) to swap all data members of the base class, except for rdbuf(), between *this and rhs. This swap function is protected: it is called by the swap functions of the swappable output stream classes std::basic_ofstream and std::basic_ostringstream, which know how to correctly swap the associated streambuffers. Parameters rhs - a basic_ostream of the same type to swap with Example #include &

class sentry; An object of class basic_ostream::sentry is constructed in local scope at the beginning of each member function of std::basic_ostream that performs output (both formatted and unformatted). Its constructor prepares the output stream: checks if the stream is already in a failed state, flushes the tie()'d output streams, and performs other implementation-defined tasks if necessary. Implementation-defined cleanup, as well as flushing of the output stream if necessary, is perfo