if statement

attr(optional) if ( condition ) statement-true (1) attr(optional) if ( condition ) statement-true else statement-false (2)

attr(optional) if ( condition ) statement-true

(1)

?

attr(optional) if ( condition ) statement-true else statement-false

(2)

?

(until C++17)

attr(C++11)

-

any number of attributes

If init-statement is used, the if statement is equivalent to. { init_statement if constexpr(optional) ( condition ) statement-true } or. { init_statement if constexpr(optional) ( condition ) statement-true else statement-false } Except that names declared by the init-statement (if init-statement is a declaration) and names declared by condition (if condition is a declaration) are in the same scope, which is also the scope of both statements. std::map<int, std::string> m; std::mutex mx; extern bool shared_flag; // guarded by mx int demo() { if (auto it = m.find(10); it != m.end()) { return it->size(); } if (char buf10; std::fgets(buf, 10, stdin)) { m0 += 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 (auto keywords = {"if", "for", "while"}; std::any_of(keywords.begin(), keywords.end(), &s { return s == kw; })) { std::cerr << "Token must not be a keyword\n"); } }

{ init_statement if constexpr(optional) ( condition ) statement-true }

?

?

{ init_statement if constexpr(optional) ( condition ) statement-true else statement-false }

?

?

(since C++17)

Constexpr If The statement that begins with if constexpr is known as the constexpr if statement. In a constexpr if statement, the value of condition must be a contextually converted constant expression of type bool. If the value is true, then statement-false is discarded (if present), otherwise, statement-true is discarded. The return statements in a discarded statement do not participate in function return type deduction: template <typename T> auto get_value(T t) { if constexpr (std::is_pointer_v<T>) return *t; // deduces return type to int for T = int* else return t; // deduces return type to int for T = int } The discarded statement can odr-use a variable that is not defined. extern int x; // no definition of x required int f() { if constexpr (true) return 0; else if (x) return x; else return -x; } If a constexpr if statement appears inside a templated entity, and if condition is not value-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 p if constexpr (sizeof...(rs) > 0) g(rs...); // never instantiated with an empty argument list. } Note: an example where the condition remains value-dependent after instantiation is a nested template, e.g. template<class T> void g() { auto lm = { if constexpr (sizeof(T) == 1 && sizeof p == 1) { // this condition remains value-dependent after instantiation of g<T> } }; } Note: the discarded statement can't be ill-formed for every possible specialization: template <typename T> void f() { if constexpr (std::is_arithmetic_v<T>) // ... else static_assert(false, "Must be arithmetic"); // ill-formed: invalid for every T } The common workaround for such a catch-all statement is a type-dependent expression that is always false: template<class T> struct dependent_false : std::false_type {}; template <typename T> void f() { if constexpr (std::is_arithmetic_v<T>) // ... else static_assert(dependent_false<T>::value, "Must be arithmetic"); // ok } Labels (goto targets, case labels, and default:) appearing in a substatement of a constexpr if can only be referenced (by switch or goto) in the same substatement.

(since C++17)

If statement-true is entered by goto or longjmp, statement_false is not executed.

(since C++14)