This header was originally in the C standard library as <setjmp.h>. This header is part of the program support library. Types jmp_buf execution context type (typedef) Macros setjmp saves the context (function macro) Functions longjmp jumps to specified location (function)

bool operator==( const regex_token_iterator& other ) const; (since C++11) bool operator!=( const regex_token_iterator& other ) const; (since C++11) Checks whether *this and other are equivalent. Two regex token iterators are equal if: a) They are both end-of-sequence iterators b) They are both suffix iterators and the suffixes are equal. c) Neither of them is end-of-sequence or suffix iterator and: position == other.position N == other.N subs == other.subs 1) C

Specifies that an instance of the type can be copy-constructed in-place by a given allocator. Requirements The type T is CopyInsertable into the container X whose value_type is identical to T if T is MoveInsertable into X, and, given. A an allocator type m an lvalue of type A p the pointer of type T* prepared by the container v expression of type (possibly const) T where X::allocator_type is identical to std::allocator_traits<A>::rebind_alloc<T>, the following e

Specifies that an instance of the type can be copy-constructed from an lvalue expression. Requirements The type T satisfies CopyConstructible if. The type T satisfies MoveConstructible, and Given. v, an lvalue expression of type T or const T or an rvalue expression of type const T u, an arbitrary identifier The following expressions must be valid and have their specified effects. Expression Post-conditions T u = v; The value of u is equivalent to the value of v. The value of v i

Specifies that an instance of the type can be copy-assigned from an lvalue expression. Requirements The type T satisfies CopyAssignable if. The type T satisfies MoveAssignable, and Given. t, a modifiable lvalue expression of type T v, an lvalue expression of type T or const T or an rvalue expression of type const T The following expressions must be valid and have their specified effects. Expression Return type Return value Post-conditions t = v T& t The value of t is equ

Initializes an object from another object. Syntax T object = other; (1) T object = {other} ; (2) (until C++11) f(other) (3) return other; (4) throw object; catch (T object). (5) T array[N] = {other}; (6) Explanation Copy initialization is performed in the following situations: 1) when a named variable (automatic, static, or thread-local) of a non-reference type T is declared with the initializer consisting of an equals sign followed by an expression.

Optimizes out copy- and move-constructors, resulting in zero-copy pass-by-value semantics. Explanation Under the following circumstances, the compilers are permitted to omit the copy- and move-constructors of class objects even if copy/move constructor and the destructor have observable side-effects. If a function returns a class type by value, and the return statement's expression is the name of a non-volatile object with automatic storage duration, which isn't the function parameter, or a

A copy constructor of class T is a non-template constructor whose first parameter is T&, const T&, volatile T&, or const volatile T&, and either there are no other parameters, or the rest of the parameters all have default values. Syntax class_name ( const class_name & ) (1) class_name ( const class_name & ) = default; (2) class_name ( const class_name & ) = delete; (3) Explanation Typical declaration of a copy constructor Forcing a copy

A copy assignment operator of class T is a non-template non-static member function with the name operator= that takes exactly one parameter of type T, T&, const T&, volatile T&, or const volatile T&. For a type to be CopyAssignable, it must have a public copy assignment operator. Syntax class_name & class_name :: operator= ( class_name ) (1) class_name & class_name :: operator= ( const class_name & ) (2) class_name & class_name :: operator= ( cons

A constructor that is not declared with the specifier explicit and which has one non-default parameter (until C++11) is called a converting constructor. Unlike explicit constructors, which are only considered during direct initialization (which includes explicit conversions such as static_cast), converting constructors are also considered during copy initialization, as part of user-defined conversion sequence. It is said that a converting constructor specifies an implicit conversion from the ty