constexpr - specifies that the value of a variable or function can appear in constant expressions Explanation The constexpr specifier declares that it is possible to evaluate the value of the function or variable at compile time. Such variables and functions can then be used where only compile time constant expressions are allowed (provided that appropriate function arguments are given). A constexpr specifier used in an object declaration implies const. A constexpr specifier used in a fun

This header is part of the thread support library. Classes condition_variable (C++11) provides a condition variable associated with a std::unique_lock (class) condition_variable_any (C++11) provides a condition variable associated with any lock type (class) cv_status (C++11) lists the possible results of timed waits on condition variables (enum) Functions notify_all_at_thread_exit (C++11) schedules a call to notify_all to be invoked when this thread is comple

Usage const type qualifier

Defines an expression that can be evaluated at compile time. Such expressions can be used as non-type template arguments, array sizes, and in other contexts that require constant expressions, e.g. int n = 1; std::array<int, n> a1; // error, n is not a constant expression const int cn = 2; std::array<int, cn> a2; // OK, cn is a constant expression Core constant expressions A core constant expression is any expression that does not have any one of the following in any subexpression

Usage declares a named type requirement(concepts TS)

This header is part of the numeric library. Classes complex a complex number type (class template) complex<float>complex<double>complex<long double> a complex number type (class template specialization) Functions Operations operator+operator- applies unary operators to complex numbers (function template) operator+operator-operator*operator/ performs complex number arithmetics on two complex values or a complex and a scalar (function template)

The preprocessor supports conditional compilation of parts of source file. This behavior is controlled by #if, #else, #elif, #ifdef, #ifndef and #endif directives. Syntax #if expression #ifdef expression #ifndef expression #elif expression #else #endif Explanation The conditional preprocessing block starts with #if, #ifdef or #ifndef directive, then optionally includes any number of #elif directives, then optionally includes at most one #else directiv

Usage alternative operators: as an alternative for ~

Compares the arguments. Operator name Syntax Over​load​able Prototype examples (for class T) As member function As free (namespace) function equal to a == b Yes bool T::operator ==(const T2 &b) const; bool operator ==(const T &a, const T2 &b); not equal to a != b Yes bool T::operator !=(const T2 &b) const; bool operator !=(const T &a, const T2 &b); less than a < b Yes bool T::operator <(const T2 &b) const; bool operator <

The class template std::ratio and associated templates provide compile-time rational arithmetic support. Each instantiation of this template exactly represents any finite rational number. Compile-time fractions Defined in header <ratio> ratio represents exact rational fraction (class template) Several convenience typedefs that correspond to the SI ratios are provided by the standard library: Defined in header <ratio> Type Definition yocto std::ratio<1, 1000