Defined in header <cfenv> #define FE_DOWNWARD /*implementation defined*/ (since C++11) #define FE_TONEAREST /*implementation defined*/ (since C++11) #define FE_TOWARDZERO /*implementation defined*/ (since C++11) #define FE_UPWARD /*implementation defined*/ (since C++11) Each of these macro constants expands to a nonnegative integer constant expression, which can be used with std::fesetround and std::fegetround to indicate one of the supporte

Changes the current file name and number in the preprocessor. Syntax #line lineno (1) #line lineno "filename" (2) Explanation 1) Changes the current preprocessor line number to lineno. Expansions of the macro __LINE__ beyond this point will expand to lineno plus the number of actual source code lines encountered since. 2) Also changes the current preprocessor file name to filename. Expansions of the macro __FILE__ from this point will produce filename. Any preprocessing toke

Defined in header <cfenv> #define FE_DFL_ENV /*implementation defined*/ (since C++11) The macro constant FE_DFL_ENV expands to an expression of type const std::fenv_t*, which points to a full copy of the default floating-point environment, that is, the environment as loaded at program startup. Additional macros that begin with FE_ followed by uppercase letters, and have the type const std::fenv_t*, may be supported by an implementation. Example #include <iostream&g

Defined in header <cfenv> #define FE_DIVBYZERO /*implementation defined power of 2*/ (since C++11) #define FE_INEXACT /*implementation defined power of 2*/ (since C++11) #define FE_INVALID /*implementation defined power of 2*/ (since C++11) #define FE_OVERFLOW /*implementation defined power of 2*/ (since C++11) #define FE_UNDERFLOW /*implementation defined power of 2*/ (since C++11) #define FE_ALL_EXCEPT FE_DIVBYZERO | FE_INEXACT

Adding declarations to std It is undefined behavior to add declarations or definitions to namespace std or to any namespace nested within std, with a few exceptions noted below. #include <utility> namespace std { // a function definition added to namespace std: undefined behavior pair<int, int> operator+(pair<int, int> a, pair<int, int> b) { return {a.first+b.first, a.second+b.second}; } } It is allowed to add template specializations for any stand

Usage static storage duration with external linkage specifier language linkage specification explicit template instantiation declaration (or "extern template")

Usage Used to mark a template definition exported, which allows the same template to be declared, but not defined, in other translation units. (until C++11) The keyword is unused and reserved. (since C++11)

An expression is a sequence of operators and their operands, that specifies a computation. Expression evaluation may produce a result (e.g., evaluation of 2+2 produces the result 4) and may generate side-effects (e.g. evaluation of std::printf("%d",4) prints the character '4' on the standard output). General value categories (lvalue, rvalue, glvalue, prvalue, xvalue) classify expressions by their values order of evaluation of arguments and subexpressions specify the order in which interme

Allows customizing the template code for a given set of template arguments. Syntax template <> declaration Any of the following can be fully specialized: function template class template (since C++14)variable template member function of a class template static data member of a class template member class of a class template member enumeration of a class template member class template of a class or class template member function template of a class or class temp

Converts between types using a combination of explicit and implicit conversions. Syntax ( new_type ) expression (1) new_type ( expression ) (2) new_type ( expressions ) (3) new_type ( ) (4) new_type { expression-list(optional) } (5) (since C++11) Returns a value of type new_type. Explanation 1) When the C-style cast expression is encountered, the compiler attempts to interpret it as the following cast expressions, in this order: a) const_cast<