Constant expressions
Defines an expression that can be evaluated at compile time.
Such expressions can be used as nontype 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 (ignoring unevaluated expressions such as the operand of sizeof
or the right operand of builtin && when the left operand evaluates to false
)
constexpr int n = std::numeric_limits<int>::max(); // OK, max() is constexpr constexpr int m = std::time(NULL); // Error: std::time() is not constexpr
constexpr
function which is declared, but not defined, or a function call to a constexpr
function/constructor template instantiation where the instantiation fails to satisfy constexpr function/constructor requirements.constexpr
function with arguments that do not produce a constant expression when substituted
constexpr const int* addr(const int& ir) { return &ir; } static const int x = 5; constexpr const int* xp = addr(x); // OK constexpr const int* tp = addr(5); // error: &5 is not a constant expression
constexpr
constructor with arguments that do not produce constant expressions in memberinitializer lists that are called from this function
int x; struct A { constexpr A(bool b) : m(b?42:x) { } int m; }; constexpr int v = A(true).m; // OK constexpr int w = A(false).m; // error: nonconst x
5) A function call to a recursive constexpr function that would exceed compiletime recursion depth limit (implementationdefined)

(until C++14) 
5) an expression that would exceed the implementationdefined limits

(since C++14) 
6) The this pointer, except if used for class member access inside a nonstatic member function

(until C++14) 
6) The this pointer, except in a constexpr function or a constexpr constructor that is being evaluated as part of the expression

(since C++14) 
constexpr double d1 = 2.0/1.0; // OK constexpr double d2 = 2.0/0.0; // Error: not defined constexpr int n = std::numeric_limits<int>::max() + 1; // Error: overflow int x, y, z[30]; constexpr auto e1 = &y  &x; // Error: undefined constexpr auto e2 = &z[20]  &z[3]; // OK constexpr std::bitset<2> a; constexpr bool b = a[2]; // UB, but unspecified if detected
8) A lambda expression

(until C++17) 
int main() { const std::size_t tabsize = 50; int tab[tabsize]; // OK: tabsize is a constant expression std::size_t n = 50; const std::size_t sz = n; int tab2[sz]; // error: sz is not a constant expression // because sz is not initialized with a constant expression }
constexpr
or to its nonmutable subobject
d) has literal type and refers to a nonvolatile temporary object, initialized with a constant expression

(until C++14) 
d) has literal type and refers to a nonvolatile object whose lifetime began within the evaluation of this expression

(since C++14) 
12) conversion from cv void* to any pointertoobject type

(since C++14) 
16) an increment or a decrement operator

(until C++14) 
16) modification of an object, unless the object has nonvolatile literal type and its lifetime began within the evaluation of the expression
constexpr int incr(int& n) { return ++n; } constexpr int g(int k) { constexpr int x = incr(k); // error: incr(k) is not a core constant // expression because lifetime of k // began outside the expression incr(k) return x; } constexpr int h(int k) { int x = incr(k); // OK: x is not required to be initialized with a core // constant expression return x; } constexpr int y = h(1); // OK: initializes y with the value 2 // h(1) is a core constant expression because // the lifetime of k begins inside the expression h(1) 
(since C++14) 
20) an assignment or a compound assignment operator

(until C++14) 
this
or to a variable defined outside that lambda, if that reference would be an odruse
void g() { const int n=0; constexpr int j=*&n; // OK, outside of a lambdaexpression [=]{ constexpr int i=n; // OK, 'n' is not odrused and not captured here. constexpr int j=*&n;// Illformed, '&n' would be an odruse of 'n'. }; }
note that if the ODRuse takes place in a function call to a closure, it does not refer to // OK: 'v' & 'm' are odrused but do not occur in a constantexpression // within the nested lambda auto monad = [](auto v){return [=]{return v;};}; auto bind = [](auto m){return [=](auto fvm){return fvm(m());};}; // OK to have captures to automatic objects created during constant expression evaluation. static_assert(bind(monad(2))(monad)() == monad(2)()); 
(since C++17) 
This section is incomplete Reason: needs more miniexamples and less standardese 
Integral constant expression
Integral constant expression is an expression of integral or unscoped enumeration type implicitly converted to a prvalue, where the converted expression is a core constant expression. If an expression of class type is used where an integral constant expression is expected, the expression is contextually implicitly converted to an integral or unscoped enumeration type.
 only integral constant expressions can be used as array bounds, the dimensions in newexpressions other than the first (until C++14), bitfield lengths, enumeration initializers when the underlying type is not fixed, nullpointer constants (until C++14), and alignments.
Converted constant expression
A converted constant expression of type T
is an expression implicitly converted to type T, where the converted expression is a constant expression, and the implicit conversion sequence contains only:
 constexpr userdefined conversions (so a class can be used where integral type is expected)
 lvaluetorvalue conversions
 integral promotions
 nonnarrowing integral conversions

(since C++17) 
 And if any reference binding takes place, it is direct binding (not one that constructs a temporary object)
 Only converted constant expressions can be used as case expressions, enumerator initializers when the underlying type is fixed, array bounds, the dimensions in newexpressions other than the first (since C++14), and as integral and enumeration (until C++17)nontype template arguments.
A contextually converted constant expression of type bool is an expression, contextually converted to bool, where the converted expression is a constant expression and the conversion sequence contains only the conversions above. Such expressions can be used in noexcept specifications and static assert declarations.
Literal constant expression
Literal constant expression is a prvalue core constant expression of nonpointer literal type (after conversions as required by context). A literal constant expression of array or class type requires that each subobject is initialized with a constant expression.
Reference constant expression
Reference constant expression is an lvalue core constant expression that designates an object with static storage duration or a function.
Address constant expression
Address constant expression is a prvalue core constant expression (after conversions required by context) of type std::nullptr_t or of a pointer type, which points to an object with static storage duration, one past the end of an array with static storage duration, to a function, or is a null pointer.
Notes
Implementations are not permitted to declare library functions as constexpr unless the standard says the function is constexpr copy elision is mandatory in constant expressions

(since C++14) 
Defect reports
The following behaviorchanging defect reports were applied retroactively to previously published C++ standards.
DR  Applied to  Behavior as published  Correct behavior 

CWG 2167  C++14  nonmember references local to an evaluation were making the evaluation nonconstexpr  nonmember references allowed 
CWG 1313  C++11  undefined behavior was permitted, and all pointer subtraction was prohibited  samearray pointer subtraction ok, UB prohibited 
CWG 1952  C++11  standard library undefined behavior was required to be diagnosed  unspecified whether library UB is diagnosed 