static_assert declaration (since C++11) - cppreference.com (original) (raw)

Performs compile-time assertion checking.

Contents

• 1 Syntax
• 2 Explanation
• 3 Notes
• 4 Keywords
• 5 Example
• 6 Defect reports
• 7 References
• 8 See also

[edit] Syntax

Declares a static assertion. If the assertion fails, the program is ill-formed, and a diagnostic error message may be generated.

1. A static assertion with fixed error message.

2. A static assertion without error message.

3. A static assertion with user-generated error message.

This syntax can only be matched if syntax (1) does not match.

[edit] Explanation

A static_assert declaration may appear at namespace and block scope (as a block declaration) and inside a class body (as a member declaration).

If bool-constexpr is well-formed and evaluates to true, or is evaluated in the context of a template definition and the template is uninstantiated, this declaration has no effect. Otherwise a compile-time error is issued, and the user-provided message, if any, is included in the diagnostic message.

The text of the user-provided message is determined as follows:

• If the message matches the syntactic requirements of unevaluated-string, the text of the message is the text of the unevaluated-string.

[edit] Notes

The standard does not require a compiler to print the verbatim text of error message, though compilers generally do so as much as possible.

[edit] Keywords

static_assert

[edit] Example

#include #include   static_assert(03301 == 1729); // since C++17 the message string is optional   template void swap(T& a, T& b) noexcept { static_assert(std::is_copy_constructible_v, "Swap requires copying"); static_assert(std::is_nothrow_copy_constructible_v && std::is_nothrow_copy_assignable_v, "Swap requires nothrow copy/assign"); auto c = b; b = a; a = c; }   template struct data_structure { static_assert(std::is_default_constructible_v, "Data structure requires default-constructible elements"); };   template constexpr bool dependent_false = false; // workaround before CWG2518/P2593R1   template struct bad_type { static_assert(dependent_false, "error on instantiation, workaround"); static_assert(false, "error on instantiation"); // OK because of CWG2518/P2593R1 };   struct no_copy { no_copy(const no_copy&) = delete; no_copy() = default; };   struct no_default { no_default() = delete; };   #if __cpp_static_assert >= 202306L // Not real C++ yet (std::format should be constexpr to work): static_assert(sizeof(int) == 4, std::format("Expected 4, got {}", sizeof(int))); #endif   int main() { int a, b; swap(a, b);   no_copy nc_a, nc_b; swap(nc_a, nc_b); // 1   [[maybe_unused]] data_structure ds_ok; [[maybe_unused]] data_structure ds_error; // 2 }

Possible output:

1: error: static assertion failed: Swap requires copying 2: error: static assertion failed: Data structure requires default-constructible elements 3: error: static assertion failed: Expected 4, got 2

[edit] Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

[edit] References

• C++23 standard (ISO/IEC 14882:2024):

• 9.1 Preamble [dcl.pre] (p: 10)

• C++20 standard (ISO/IEC 14882:2020):

• 9.1 Preamble [dcl.pre] (p: 6)

• C++17 standard (ISO/IEC 14882:2017):

• 10 Declarations [dcl.dcl] (p: 6)

• C++14 standard (ISO/IEC 14882:2014):

• 7 Declarations [dcl.dcl] (p: 4)

• C++11 standard (ISO/IEC 14882:2011):

• 7 Declarations [dcl.dcl] (p: 4)

[edit] See also