Objects, references, functions including function template specializations, and expressions have a property called type, which both restricts the operations that are permitted for those entities and provides semantic meaning to the otherwise generic sequences of bits. Type classification The C++ type system consists of the following types: fundamental types (see also std::is_fundamental): the type void (see also std::is_void); the type std::nullptr_t (see also std::is_null_pointer); a

This header is part of the general utility library. Classes tuple (C++11) implements fixed size container, which holds elements of possibly different types (class template) tuple_size obtains the size of tuple at compile time (class template specialization) tuple_element obtains the type of the specified element (class template specialization) std::uses_allocator<std::tuple> (C++11) specializes the std::uses_allocator type trait (class template specialization)

Associates one or more exception handlers (catch-clauses) with a compound statement. Syntax try compound-statement handler-sequence where handler-sequence is a sequence of one or more handlers, which have the following syntax: catch ( attr(optional) type-specifier-seq declarator ) compound-statement (1) catch ( attr(optional) type-specifier-seq abstract-declarator(optional) ) compound-statement (2) catch ( ... ) compound-statement (3) compound-statement - bra

Usage try-catch block

Usage boolean literal

Specifies that a type is trivial type. Note, that the standard doesn't define a named requirement or concept with this name. This is a type category defined by the core language. It is included here as concept only for consistency. Requirements TriviallyCopyable Trivial default constructor See also is_trivial (C++11) checks if a type is trivial (class template)

Requirements Trivial copy constructor Trivial move constructor Trivial copy assignment operator Trivial move assignment operator Trivial destructor No virtual functions or virtual base classes All (non-static) members and base classes are TriviallyCopyable Scalar types and arrays of TriviallyCopyable objects are TriviallyCopyable as well, as well as the const-qualified (but not volatile-qualified) versions of such types. See also is_trivially_copyable (C++11) checks if

The TrivialClock concept describes the requirements satisfied by all the clocks in the chrono library. Requirements For a type TC: The type must meet Clock requirements. The types TC::rep, TC::duration, and TC::time_point satisfy the requirements of EqualityComparable, LessThanComparable, DefaultConstructible, CopyConstructible, CopyAssignable, Destructible, and NumericType. lvalues of the types TC::rep, TC::duration, and TC::time_point are Swappable. The function TC::now() does not t

Transactional memory is a concurrency synchronization mechanism that combines groups of statements in transactions, that are. atomic (either all statements occur, or nothing occurs) isolated (statements in a transaction may not observe half-written writes made by another transaction, even if they execute in parallel) Typical implementations use hardware transactional memory where supported and to the limits that it is available (e.g. until the changeset is saturated) and fall back to soft

The TimedMutex concept extends the TimedLockable concept to include inter-thread synchronization. Requirements TimedLockable Mutex Additionally, for object m of TimedMutex type. The expression m.try_lock_for(duration) has the following properties Behaves as an atomic operation. Attempts to obtain exclusive ownership of the mutex within the duration specified by duration. If duration is less or equal duration.zero(), attempts to obtain the ownership without locking (as if by try_loc