Constant expressions

From cppreference.com

Compiler support
Language
Headers
Type support
Program utilities
Variadic function support
Error handling
Dynamic memory management
Strings library
Algorithms
Numerics
Date and time utilities
Input/output support
Localization support
Concurrency support(C11)
Technical Specifications
Symbol index

[edit]

C language

Basic concepts
Keywords
Preprocessor
Statements
Expressions
Initialization
Declarations
Functions
Miscellaneous
History of C
Technical Specifications

[edit]

Expressions

General
Value category
Evaluation order and sequence points
Constant expressions
Implicit conversions
Generic selection(C11)
Constants and literals
Integer constant
Floating constant
Character constant
`true`/`false` (C23)
`nullptr` (C23)
String literal
Compound literal(C99)
Operators
Operator precedence
Member access and indirection
Logical operators
Comparison operators
Arithmetic operators
Assignment operators
Increment and decrement
Function call, comma, conditional operator
sizeof
`_Alignof` (C11*)
Cast operators

[edit]

Several varieties of expressions are known asconstant expressions.

[edit]Preprocessor constant expression

The expression following#if or#elif must expand to

operators other thanassignment,increment, decrement,function-call, orcomma whose arguments are preprocessor constant expressions
integer constants
character constants
the special preprocessor operatordefined.

Character constants, when evaluated in#if-expressions, may be interpreted in the sourcecharacter set, the execution character set, or some other implementation-defined character set.

Integer arithmetic in#if-expressions is performed using the semantics ofintmax_t for signed types anduintmax_t for unsigned types.

(since C99)

[edit]Integer constant expression

An integer constant expression is an expression that consists only of

operators other thanassignment,increment, decrement,function-call, orcomma, except thatcast operators can only cast arithmetic types to integer types unless they are part of an operand to a sizeof, _Alignof(since C11)(until C23), alignas(since C23)or typeof/typeof_unqual(since C23) operator.
integer constants
enumeration constants
character constants
floating constants, but only if they are immediately used as operands of casts to integer type
sizeof operators whose operands are not VLA(since C99)

_Alignof(until C23)alignas(since C23) operators

(since C11)

named and compound literal constants that are of integer type or that are of arithmetic type and are the immediate operands of casts

(since C23)

Integer constant expressions are evaluated at compile time. The following contexts require expressions that are known asinteger constant expressions:

The size of abit-field.
The value of anenumeration constant
Thecase label of aswitch statement
The size of anon-VLA(since C99) array
Integer to pointer implicitconversion.

The index in anarray designator	(since C99)
The first argument of`_Static_assert` The integer argument of`_Alignof`(until C23)`alignof`(since C23)	(since C11)
The number of bits N of a bit-precise integer type (_BitInt(N))	(since C23)

[edit]Static initializer

Expressions that are used in theinitializers of objects with static and thread_localstorage durationor declared with theconstexpr storage-class specifier(since C23) must be either string literals or expressions that may be one of the following

1)arithmetic constant expression, which is an expression of any arithmetic type that consists of

operators other thanassignment,increment, decrement,function-call, orcomma, except thatcast operators must be converting arithmetic types to other arithmetic types unless they are part of an operand to a sizeof, _Alignof(since C11)(until C23), alignof(since C23)or typeof/typeof_unqual(since C23) operator
integer constants
floating constants
enumeration constants
character constants
sizeof operatorswhose operands are not VLA(since C99)

_Alignof(until C23)alignof(since C23) operators

(since C11)

named or compound literal constants of arithmetic type

(since C23)

2) a null pointer constant (e.g.,NULL).

3)address constant expression, which is

a null pointer
lvalue designating an object of staticstorage duration or a function designator, converted to a pointer either

by using the unary address-of operator
by casting an integer constant to a pointer
by array-to-pointer or function-to-pointer implicitconversion.

4)address constant expression of some complete object type, plus or minus aninteger constant expression.

5) anamed constant which is, an identifier that is

an enumeration constant
a predefined constant (one oftrue,false ornullptr)
declared with storage-class specifierconstexpr and has an object type

or a postfix expression that applies the. member access operator to a named constant of structure or union type, even recursively.

6) acompound literal constant, which is

acompound literal with storage-class specifierconstexpr
a postfix expression that applies the. member access operator to a compound literal constant of structure or union type, even recursively.

Astructure or union constant is a named constant or compound literal constant with structure or union type, respectively. If the member-access operator. accesses a member of a union constant, the accessed member shall be the same as the member that is initialized by the union constant’s initializer.

(since C23)

7) constant expression of one of the other forms accepted by the implementation.

Unlike with integer constant expressions, static initializer expressions are not required to be evaluated at compile time; the compiler is at liberty to turn such initializers into executable code which is invoked prior to program startup.

staticint i=2||1/0;// initializes i to value 1

This section is incomplete
Reason: other mini-examples

The value of a floating-point static initializer is never less accurate than the value of the same expression executed at run time, but it may be better.

[edit]Floating-point constant expressions

Arithmetic constant expressions of floating-point types that are not used in static initializers are always evaluated as-if during run-time and are affected by thecurrent rounding (ifFENV_ACCESS is on) and report errors as specified inmath_errhandling.

void f(void){#pragma STDC FENV_ACCESS ONstaticfloat x=0.0/0.0;// static initializer: does not raise an exceptionfloat w[]={0.0/0.0};// raises an exceptionfloat y=0.0/0.0;// raises an exceptiondouble z=0.0/0.0;// raises an exception}

[edit]Notes

If an expression evaluates to a value that is not representable by its type, it cannot be used as a constant expression.

Implementations may accept other forms of constant expressions. However, these constant expressions are not considered as integer constant expressions, arithmetic constant expressions, or address constant expressions, and thus cannot be used in the contexts requiring these kinds of constant expressions. For example,int arr[(int)+1.0]; declares a VLA.