• 1Syntax
• 2Condition
  • 2.1Expression
  • 2.2Declaration
    • 2.2.1Non-structured binding declaration
    • 2.2.2Structured binding declaration
• 3Branch selection
• 4if statements with initializer
• 5Constexpr if
• 6Consteval if
• 7Notes
• 8Keywords
• 9Defect reports
• 10See also

• anexpression statement (which may be a null statement;)
• asimple declaration, typically a declaration of a variable with initializer, but it may declare arbitrary many variables or be astructured binding declaration

Note that anyinit-statement must end with a semicolon. This is why it is often described informally as an expression or a declaration followed by a semicolon.

• If it can be syntactically resolved as astructured binding declaration, it is interpreted as a structured binding declaration.

• type-specifier-seqdeclarator=assignment-expression

• attribute-specifier-seq(optional)decl-specifier-seqdeclaratorbrace-or-equal-initializer

Structured binding declaration

The declaration has the following restrictions:

• Theexpression in itsinitializer cannot be of an array type.
• Thedeclaration specifier sequence can only contain type specifiers andconstexpr.

The decision variable of the declaration is the invented variableeintroduced by the declaration.

if statements with initializer

Ifinit-statement is used, theif statement is equivalent to

or

Except that names declared by theinit-statement (ifinit-statement is a declaration) and names declared bycondition (ifcondition is a declaration) are in the same scope, which is also the scope of bothstatement s.

std::map<int,std::string> m;std::mutex mx;externbool shared_flag;// guarded by mx int demo(){if(auto it= m.find(10); it!= m.end())return it->second.size(); if(char buf[10];std::fgets(buf,10,stdin))        m[0]+= buf; if(std::lock_guard lock(mx); shared_flag){        unsafe_ping();        shared_flag=false;} if(int s;int count= ReadBytesWithSignal(&s)){        publish(count);        raise(s);} if(constauto keywords={"if","for","while"};        std::ranges::any_of(keywords,[&tok](constchar* kw){return tok== kw;})){std::cerr<<"Token must not be a keyword\n";}}

Constexpr if

The statement that begins withifconstexpr is known as theconstexpr if statement. All substatements of a constexpr if statement arecontrol-flow-limited statements.

In a constexpr if statement,condition must beacontextually converted constant expression of typebool(until C++23)an expressioncontextually converted tobool, where the conversion is aconstant expression(since C++23).

Ifcondition yieldstrue, thenstatement-false is discarded (if present), otherwise,statement-true is discarded.

Thereturn statements in a discarded statement do not participate in function return type deduction:

template<typename T>auto get_value(T t){ifconstexpr(std::is_pointer_v<T>)return*t;// deduces return type to int for T = int*elsereturn t;// deduces return type to int for T = int}

The discarded statement canODR-use a variable that is not defined:

externint x;// no definition of x required int f(){ifconstexpr(true)return0;elseif(x)return x;elsereturn-x;}

Outside a template, a discarded statement is fully checked.ifconstexpr is not a substitute for the#if preprocessing directive:

void f(){ifconstexpr(false){int i=0;int*p= i;// Error even though in discarded statement}}

If a constexpr if statement appears inside atemplated entity, and ifcondition is notvalue-dependent after instantiation, the discarded statement is not instantiated when the enclosing template is instantiated.

template<typename T,typename ...Rest>void g(T&& p, Rest&& ...rs){// ... handle pifconstexpr(sizeof...(rs)>0)        g(rs...);// never instantiated with an empty argument list}

The condition remains value-dependent after instantiation is a nested template:

template<class T>void g(){auto lm=[=](auto p){ifconstexpr(sizeof(T)==1&& sizeof p==1){// this condition remains value-dependent after instantiation of g<T>,// which affects implicit lambda captures// this compound statement may be discarded only after// instantiation of the lambda body}};}

The discarded statement cannot be ill-formed for every possible specialization:

template<typename T>void f(){ifconstexpr(std::is_arithmetic_v<T>)// ...else{using invalid_array=int[-1];// ill-formed: invalid for every T        static_assert(false,"Must be arithmetic");// ill-formed before CWG2518}}

The common workaround before the implementation ofCWG issue 2518 for such a catch-all statement is a type-dependent expression that is alwaysfalse:

template<typename>constexprbool dependent_false_v=false; template<typename T>void f(){ifconstexpr(std::is_arithmetic_v<T>)// ...else{// workaround before CWG2518        static_assert(dependent_false_v<T>,"Must be arithmetic");}}

Atypedef declarationoralias declaration(since C++23) can be used as theinit-statement of a constexpr if statement to reduce the scope of the type alias.

Consteval if

The statement that begins withif consteval is known as theconsteval if statement. All substatements of a consteval if statement arecontrol-flow-limited statements.

statement must be a compound statement, and it will still be treated as a part of the consteval if statement even if it is not a compound statement (and thus results in a compilation error):

constexprvoid f(bool b){if(true)if consteval{}else;// error: not a compound-statement// else not associated with outer if}

If a consteval if statement is evaluated in amanifestly constant-evaluated context,compound-statement is executed. Otherwise,statement is executed if it is present.

If the statement begins withif!consteval, thecompound-statement andstatement (if any) must both be compound statements. Such statements are not considered consteval if statements, but are equivalent to consteval if statements:

• if!consteval{/* stmt */} is equivalent to
  

if consteval{}else{/* stmt */}.

• if!consteval{/* stmt-1 */}else{/* stmt-2 */} is equivalent to
  

if consteval{/* stmt-2 */}else{/* stmt-1 */}.

compound-statement in a consteval if statement (orstatement in the negative form) is in animmediate function context, in which a call to an immediate function needs not to be a constant expression.

#include <cmath>#include <cstdint>#include <cstring>#include <iostream> constexprbool is_constant_evaluated()noexcept{if consteval{returntrue;}else{returnfalse;}} constexprbool is_runtime_evaluated()noexcept{if not consteval{returntrue;}else{returnfalse;}} constevalstd::uint64_t ipow_ct(std::uint64_t base,std::uint8_t exp){if(!base)return base;std::uint64_t res{1};while(exp){if(exp&1) res*= base;        exp/=2;        base*= base;}return res;} constexprstd::uint64_t ipow(std::uint64_t base,std::uint8_t exp){if consteval// use a compile-time friendly algorithm{return ipow_ct(base, exp);}else// use runtime evaluation{returnstd::pow(base, exp);}} int main(int,constchar* argv[]){    static_assert(ipow(0,10)==0&& ipow(2,10)==1024);std::cout<< ipow(std::strlen(argv[0]),3)<<'\n';}

Built-in conversions are not allowed in thecondition of a constexpr if statement, except for non-narrowingintegral conversions tobool.