Defined in header <regex> std::regex_constants::error_type code() const; (since C++11) Returns the std::regex_constants::error_type that was passed to the std::regex_error constructor. See Also error_type (C++11) describes different types of matching errors (typedef) (constructor) constructs a regex_error object (public member function)

Defined in header <regex> class regex_error; (since C++11) Defines the type of exception object thrown to report errors in the regular expressions library. Inheritance diagram. Member functions (constructor) constructs a regex_error object (public member function) code gets the std::regex_constants::error_type for a regex_error (public member function) Inherited from std::exception Member functions (destructor) [virtual] destructs the exce

Defined in header <regex> typedef /*unspecified*/ syntax_option_type; constexpr syntax_option_type icase = /*unspecified*/; constexpr syntax_option_type nosubs = /*unspecified*/; constexpr syntax_option_type optimize = /*unspecified*/; constexpr syntax_option_type collate = /*unspecified*/; constexpr syntax_option_type ECMAScript = /*unspecified*/; constexpr syntax_option_type basic = /*unspecified*/; constexpr syntax_option_type extended = /*unspecified*/; constexpr syntax_option

Defined in header <regex> typedef /*unspecified*/ match_flag_type; constexpr match_flag_type match_default = 0; constexpr match_flag_type match_not_bol = /*unspecified*/; constexpr match_flag_type match_not_eol = /*unspecified*/; constexpr match_flag_type match_not_bow = /*unspecified*/; constexpr match_flag_type match_not_eow = /*unspecified*/; constexpr match_flag_type match_any = /*unspecified*/; constexpr match_flag_type match_not_null = /*unspecified*/; constexpr match_flag_t

Defined in header <regex> typedef /*implementation defined*/ error_type; (since C++11) constexpr error_type error_collate = /*unspecified*/; constexpr error_type error_ctype = /*unspecified*/; constexpr error_type error_escape = /*unspecified*/; constexpr error_type error_backref = /*unspecified*/; constexpr error_type error_brack = /*unspecified*/; constexpr error_type error_paren = /*unspecified*/; constexpr error_type error_brace = /*unspecified*/; constexpr error_type er

reference_wrapper( T& x ); (since C++11) reference_wrapper( T&& x ) = delete; (since C++11) reference_wrapper( const reference_wrapper<T>& other ); (since C++11) Constructs a new reference wrapper. 1) Stores a reference to x. 2) Construction from a temporary object is not allowed. 3) Copy constructor. Stores a reference to other.get(). Parameters x - an object to wrap other - another reference wrapper Exceptions noexcept specificati

operator T& () const; (since C++11) T& get() const; (since C++11) Returns the stored reference. Parameters (none). Return value The stored reference. Exceptions 1-2) noexcept specification: noexcept See also operator() calls the stored function (public member function)

Defined in header <functional> template< class T > class reference_wrapper; (since C++11) std::reference_wrapper is a class template that wraps a reference in a copyable, assignable object. It is frequently used as a mechanism to store references inside standard containers (like std::vector) which cannot normally hold references. Specifically, std::reference_wrapper is a CopyConstructible and CopyAssignable wrapper around a reference to object or reference to function

Defined in header <functional> template< class T > std::reference_wrapper<T> ref(T& t); (1) (since C++11) template< class T > std::reference_wrapper<T> ref( std::reference_wrapper<T> t ); (2) (since C++11) template <class T> void ref(const T&&) = delete; (3) (since C++11) template< class T > std::reference_wrapper<const T> cref( const T& t ); (4) (since C++11) template< class T > std::ref

void unlock(); (since C++11) Unlocks the mutex if its level of ownership is 1 (there was exactly one more call to lock() than there were calls to unlock() made by this thread), reduces the level of ownership by 1 otherwise. The mutex must be locked by the current thread of execution, 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). Retur