Defined in header <regex> regex_error(std::regex_constants::error_type ecode); (since C++11) Constructs a regex_error with a given ecode of type std::regex_constants::error_type . See Also error_type (C++11) describes different types of matching errors (typedef)

template< class BidirIt, class CharT = typename std::iterator_traits<BidirIt>::value_type, class Traits = std::regex_traits<CharT> > class regex_iterator (since C++11) std::regex_iterator is a read-only ForwardIterator that accesses the individual matches of a regular expression within the underlying character sequence. On construction, and on every increment, it calls std::regex_search and remembers the result (that is, saves a copy of the value std::match

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 <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

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 <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 <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

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

template< class Clock, class Duration > bool try_lock_until( const std::chrono::time_point<Clock,Duration>& timeout_time ); (since C++11) Tries to lock the mutex. 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. If timeout_time has already passed, this function behaves like try_lock(). The clock tied to timeout_time is used, which means that adjustmen