const_reference suffix() const; (since C++11) Obtains a reference to the std::sub_match object representing the target sequence between the end of the entire match of the regular expression and the end of the target sequence. The behavior is undefined unless ready() == true. Parameters (none). Return value Reference to the unmatched suffix. Example #include <iostream> #include <regex> #include <string> int main() { std::regex re("a(a)*b"); std::str

template< class R, class... Args > void swap( function<R(Args...)> &lhs, function<R(Args...)> &rhs ); Overloads the std::swap algorithm for std::function. Exchanges the state of lhs with that of rhs. Effectively calls lhs.swap(rhs). Parameters lhs, rhs - polymorphic function wrappers whose states to swap Return value (none). Exceptions (none). Example See also swap swaps the contents (public member function)

Defined in header <chrono> template <class Rep> struct treat_as_floating_point : std::is_floating_point<Rep> {}; (since C++11) The std::chrono::treat_as_floating_point trait helps determine if a duration can be converted to another duration with a different tick period. Implicit conversions between two durations normally depends on the tick period of the durations. However, implicit conversions can happen regardless of tick period if std::chrono::treat_as_float

native_handle_type native_handle(); (since C++11) Returns the implementation defined underlying thread handle. Parameters (none). Return value implementation defined handle type representing the thread. Exceptions (none). Example Uses native_handle to enable realtime scheduling of C++ threads on a POSIX system. #include <thread> #include <mutex> #include <iostream> #include <chrono> #include <cstring> #include <pthread.h> std::mutex iom

void swap( multiset& other ); Exchanges the contents of the container with those of other. Does not invoke any move, copy, or swap operations on individual elements. All iterators and references remain valid. The past-the-end iterator is invalidated. The Pred objects must be Swappable, and they are exchanged using unqualified call to non-member swap. If std::allocator_traits<allocator_type>::propagate_on_container_swap::value is true, then the allocators are exchanged using a

void swap( function& other ); (since C++11) Exchanges the stored callable objects of *this and other. Parameters other - function wrapper to exchange the stored callable object with Return value (none). Exceptions noexcept specification: noexcept

void clear(); (since C++11) Removes all elements from the container. Invalidates any references, pointers, or iterators referring to contained elements. May invalidate any past-the-end iterators. Parameters (none). Return value (none). Exceptions noexcept specification: noexcept Complexity Linear in the size of the container. See also erase erases elements (public member function)

Defined in header <valarray> template< class T > valarray<T> abs( const valarray<T>& va ); Computes absolute value of each element in the value array. Parameters va - value array to apply the operation to Return value Value array containing absolute values of the values in va. Notes Unqualified function (abs) is used to perform the computation. If such function is not available, std::abs is used due to argument dependent lookup. The fu

Defined in header <atomic> enum memory_order { memory_order_relaxed, memory_order_consume, memory_order_acquire, memory_order_release, memory_order_acq_rel, memory_order_seq_cst }; (since C++11) std::memory_order specifies how regular, non-atomic memory accesses are to be ordered around an atomic operation. Absent any constraints on a multi-core system, when multiple threads simultaneously read and write to several variables, one thread can observe t

static bool sync_with_stdio( bool sync = true ); Sets whether the standard C++ streams are synchronized to the standard C streams after each input/output operation. The standard C++ streams are the following: std::cin, std::cout, std::cerr, std::clog, std::wcin, std::wcout, std::wcerr and std::wclog. The standard C streams are the following: stdin, stdout and stderr. For a standard stream str, synchronized with the C stream f, the following pairs of functions have identical effect: 1)