Linux Manuals

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…

std::optional<T>::operator->,std::optional<T>::operator* – std::optional<T>::operator->,std::optional<T>::operator* Synopsis constexpr const T* operator->() const; (1) (since C++17) constexpr T* operator->(); (1) (since C++17) constexpr const T& operator*() const&; (2) (since C++17) constexpr T& operator*() &; (2) (since C++17) constexpr const T&& operator*() const&&; (2) (since C++17) constexpr T&& operator*() &&; (2) (since C++17) Accesses the contained value. 1) Returns a…

std::optional<T>::emplace – std::optional<T>::emplace Synopsis template< class… Args > (since C++17) T& emplace( Args&&… args ); template< class U, class… Args > (since C++17) T& emplace( std::initializer_list<U> ilist, Args&&… args ); Constructs the contained value in-place. If *this already contains a value before the call, the contained value is destroyed by calling its destructor. 1) Initializes…

std::optional – std::optional Synopsis Defined in header <optional> template< class T > (since C++17) class optional; The class template std::optional manages an optional contained value, i.e. a value that may or may not be present. A common use case for optional is the return value of a function that may fail. As opposed to other…

std::operator==,!=,<(std::error_code) – std::operator==,!=,<(std::error_code) Synopsis Defined in header <system_error> bool operator==( const error_code& lhs, const error_code& rhs ) noexcept; (1) (since C++11) bool operator!=( const error_code& lhs, const error_code& rhs ) noexcept; (1) (since C++11) bool operator<( const error_code& lhs, const error_code& rhs ) noexcept; (1) (since C++11) Compares two error code objects. 1) Compares lhs…

std::operator+(std::basic_string) – std::operator+(std::basic_string) Synopsis template <class CharT, class Traits, class Alloc> basic_string<CharT, Traits, Alloc>(1) operator+(const basic_string<CharT, Traits, Alloc> &lhs, const basic_string<CharT, Traits, Alloc> &rhs); template <class CharT, class Traits, class Alloc> basic_string<CharT, Traits, Alloc>(2) operator+(const basic_string<CharT, Traits, Alloc> &lhs, const CharT *rhs); template <class CharT, class Traits, class Alloc> basic_string<CharT, Traits, Alloc>(3) operator+(const basic_string<CharT, Traits,…

std::once_flag – std::once_flag Synopsis Defined in header <mutex> class once_flag; (since C++11) The class std::once_flag is a helper structure for std::call_once. An object of type std::once_flag that is passed to multiple calls to std::call_once allows those calls to coordinate with each other such that only one of the calls will actually run to completion. std::once_flag…

std::basic_ofstream – std::basic_ofstream Synopsis Defined in header <fstream> template< class CharT, class Traits = std::char_traits<CharT> > class basic_ofstream : public std::basic_ostream<CharT, Traits> The class template basic_ofstream implements high-level output operations on file based streams. It interfaces a file-based streambuffer (std::basic_filebuf) with the high-level interface of (std::basic_ostream). A typical implementation of std::basic_ofstream holds only one non-derived…

std::numpunct_byname – std::numpunct_byname Synopsis Defined in header <locale> template< class CharT > class numpunct_byname : public std::numpunct<CharT>; std::numpunct_byname is a std::numpunct facet which encapsulates numeric punctuation preferences of a locale specified at its construction. Two specializations are provided by the standard library Defined in header <locale> std::numpunct_byname<char> locale-specific std::numpunct facet for narrow character I/O std::numpunct_byname<wchar_t>…