The Linux Manuals (man pages) document is an important part of Linux documents. Linux Manuals are organized as several sections. Each section has a group of commands for a specific area in Linux usage, administration or development.
std::ostrstream::str – std::ostrstream::str Synopsis char *str(); Returns the pointer to the beginning of the buffer, after freezing it. Effectively calls rdbuf()->str() Notes Before a call to str() that uses the result as a C string, the stream buffer must be null-terminated. Regular output such as with stream << 1.2 does not store a null terminator,…
std::ostrstream::rdbuf – std::ostrstream::rdbuf Synopsis 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 // Run this code #include <strstream> int main() { const std::ostrstream buf; std::strstreambuf *ptr =…
std::ostrstream::pcount – std::ostrstream::pcount Synopsis int pcount() const; Returns the number of characters that were output in the put area of the associated std::strstreambuf. Effectively calls rdbuf()->pcount() Parameters (none) Return value The number of characters in the put area, or zero if nothing was output. Example // Run this code #include <strstream> #include <iostream> int main()…
std::ostrstream::~ostrstream – std::ostrstream::~ostrstream Synopsis virtual ~ostrstream(); Destroys a std::ostrstream object, which also destroys the member std::strstreambuf, which may call the deallocation function if the underlying buffer was dynamically-allocated and not frozen. Parameters (none) Notes If str() was called on a dynamic ostrstream and freeze(false) was not called after that, this destructor leaks memory. Example //…
std::ostrstream::freeze – std::ostrstream::freeze Synopsis void freeze(bool flag = true); If the stream is using a dynamically-allocated array for output, disables (flag == true) or enables (flag == false) automatic allocation/deallocation of the buffer. Effectively calls rdbuf()->freeze(flag) Notes After a call to str(), dynamic streams become frozen automatically. A call to freeze(false) is required before exiting…
std::ostrstream – std::ostrstream Synopsis Defined in header <strstream> class ostrstream : public std::ostream (deprecated in C++98) The class ostrstream implements output operations on array-backed streams. It essentially wraps a raw array I/O device implementation (std::strstreambuf) into the higher-level interface of std::basic_ostream. The typical implementation of ostrstream holds only one non-derived data member: an object of…
std::basic_ostringstream::swap – std::basic_ostringstream::swap Synopsis 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 This section is incomplete Reason: no example See also operator= moves the string stream…
std::basic_ostringstream::rdbuf – std::basic_ostringstream::rdbuf Synopsis 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 This section is incomplete Reason: no example
std::basic_ostringstream::operator= – std::basic_ostringstream::operator= Synopsis basic_ostringstream& operator=( basic_ostringstream&& other ); (since C++11) Move assigns the string stream other to *this, effectively move-assigning both the std::basic_ostream base class and the associated std::basic_stringbuf. Note that the base class move assignment swaps all stream state variables (except for rdbuf) between *this and other. Parameters other – string stream to…
std::basic_ostringstream – std::basic_ostringstream Synopsis Defined in header <sstream> template< class CharT, (until C++11) class Traits = std::char_traits<CharT> > class basic_ostringstream; template< class CharT, class Traits = std::char_traits<CharT>, (since C++11) class Allocator = std::allocator<CharT> > class basic_ostringstream; The class template std::basic_ostringstream implements output operations on memory (std::basic_string) based streams. It essentially wraps a raw string device…
std::ostreambuf_iterator<CharT,Traits>::ostreambuf_iterator – std::ostreambuf_iterator<CharT,Traits>::ostreambuf_iterator Synopsis ostreambuf_iterator( streambuf_type* buffer ) throw(); (until C++11) ostreambuf_iterator( streambuf_type* buffer ) noexcept; (1) (since C++11) ostreambuf_iterator( ostream_type& stream ) throw(); (2) (until C++11) ostreambuf_iterator( ostream_type& stream ) noexcept; (since C++11) 1) Constructs the iterator with the private streambuf_type* member set to buffer and the failed() bit set to false. The behavior…
std::ostream_iterator<T,CharT,Traits>::~ostream_iterator – std::ostream_iterator<T,CharT,Traits>::~ostream_iterator Synopsis ~ostream_iterator() Destructs the iterator. Does not affect the associated output stream.
std::basic_ostream – std::basic_ostream Synopsis Defined in header <ostream> template< class CharT, class Traits = std::char_traits<CharT> > class basic_ostream : virtual public std::basic_ios<CharT, Traits> The class template basic_ostream provides support for high level output operations on character streams. The supported operations include formatted output (e.g. integer values) and unformatted output (e.g. raw characters and character arrays)….
std::optional<T>::value_or – std::optional<T>::value_or Synopsis template <class U> (since C++ 17) constexpr T value_or(U &&default_value) const &; template <class U> (since C++ 17) constexpr T value_or(U &&default_value) &&; Returns the contained value if *this has a value, otherwise returns default_value. 1) Equivalent to bool(*this) ? **this : static_cast<T>(std::forward<U>(default_value)) 2) Equivalent to bool(*this) ? std::move(**this) : static_cast<T>(std::forward<U>(default_value))…
std::optional<T>::value – std::optional<T>::value Synopsis constexpr T &value() &; (1)(since C++ 17) constexpr const T &value() const &; constexpr T &&value() &&; (2)(since C++ 17) constexpr const T &&value() const &&; If *this contains a value, returns a reference to the contained value. Otherwise, throws a std::bad_optional_access exception. Parameters (none) Return value A reference to the…
std::optional<T>::swap – std::optional<T>::swap Synopsis void swap(optional &other) noexcept(/* see below */); (since C++ 17) Swaps the contents with those of other. * If neither *this nor other contain a value, the function has no effect. * If only one of *this and other contains a value (let’s call this object in and the other un),…
std::optional<T>::reset – std::optional<T>::reset Synopsis void reset() noexcept; (since C++ 17) If *this contains a value, destroy that value as if by value().T::~T(). Otherwise, there are no effects. *this does not contain a value after this call. See also assigns contents operator= (public member function)
std::optional<T>::~optional – std::optional<T>::~optional Synopsis ~optional(); (since C++17) If the object contains a value and the type T is not trivially destructible (see std::is_trivially_destructible), destroys the contained value by calling its destructor, as if by value().T::~T(). Otherwise, does nothing. Notes If T is trivially-destructible, then this destructor is also trivial, so optional<T> is also trivially-destructible.
std::optional<T>::operatorbool,std::optional<T>::has_value – std::optional<T>::operatorbool,std::optional<T>::has_value Synopsis constexpr explicit operator bool() const noexcept; (since C++17) constexpr bool has_value() const noexcept; (since C++17) Checks whether *this contains a value. Parameters (none) Return value true if *this contains a value, false if *this does not contain a value.
std::optional<T>::operator= – std::optional<T>::operator= Synopsis optional &operator=(std::nullopt_t) noexcept; (1)(since C++ 17) constexpr optional & operator=(const optional &other); (2)(since C++ 17) constexpr optional & operator=(optional &&other) noexcept(/* see below */); (3)(since C++ 17) template <class U = T> (4)(since C++ 17) optional & operator=(U &&value); template <class U> (5)(since C++ 17) optional & operator=(const optional<U> &other); template…