contract_assert statement (since C++26)

 

C++

Compiler support

Freestanding and hosted

Language

Standard library

Standard library headers

Named requirements

Feature test macros (C++20)

Language support library

Concepts library (C++20)

Diagnostics library

Memory management library

Metaprogramming library (C++11)

General utilities library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Strings library

Text processing library

Numerics library

Date and time library

Input/output library

Filesystem library (C++17)

Concurrency support library (C++11)

Execution control library (C++26)

Technical specifications

Symbols index

External libraries

 

C++ language

General topics
Preprocessor Comments	Keywords Escape sequences
Flow control
Conditional execution statements
if	switch
Iteration statements (loops)
for range-for (C++11)	while do-while
Jump statements
continue - break	goto - return
Functions
Function declaration
Lambda function expression
inline specifier
Dynamic exception specifications (until C++17*)
noexcept specifier (C++11)
Exceptions
throw-expression try block	catch handler
Namespaces
Namespace declaration	Namespace aliases
Types
Fundamental types Enumeration types Function types	Class/struct types Union types
Specifiers
const/volatile decltype (C++11) auto (C++11)	constexpr (C++11) consteval (C++20) constinit (C++20)
Storage duration specifiers
Initialization
Default-initialization Value-initialization Zero-initialization Copy-initialization Direct-initialization	Aggregate initialization List-initialization (C++11)   Constant initialization Reference initialization

Expressions
Value categories Order of evaluation	Operators Operator precedence
Alternative representations
Literals
Boolean - Integer - Floating-point
Character - String - nullptr (C++11)
User-defined (C++11)
Utilities
Attributes (C++11)
Types
typedef declaration
Type alias declaration (C++11)
Casts
Implicit conversions static_cast const_cast	Explicit conversions dynamic_cast reinterpret_cast
Memory allocation
new expression	delete expression
Classes
Class declaration Constructors this pointer	Access specifiers friend specifier
Class-specific function properties
Virtual function override specifier (C++11)   final specifier (C++11)	explicit (C++11) static
Special member functions
Default constructor Copy constructor Move constructor (C++11)	Copy assignment Move assignment (C++11) Destructor
Templates
Class template Function template	Template specialization Parameter packs (C++11)
Miscellaneous
Inline assembly	History of C++

 

Statements

Labels

label : statement

Expression statements

expression ;

Compound statements

{ statement... }

Selection statements

if

switch

Iteration statements

while

do while

for

range for (C++11)

Jump statements

break

continue

return

goto

Assertions

contract_assert (C++26)

Declaration statements

declaration ;

Try blocks

try block

Transactional memory

synchronized, atomic_commit, etc (TM TS)

 

A contract_assert statement is a contract assertion that may appear in a function or lambda body to verify an internal condition. It ensures the condition holds during execution, triggering a violation (e.g. termination) in debug builds if the condition evaluates to false or the evaluation exits via an exception, and can be ignored in release builds for performance.

Syntax

contract_assert attr (optional) ( predicate ) ;

attr	-	any number of attributes
predicate	-	boolean expression that should evaluate to true

Keywords

contract_assert

Notes

Feature-test macro	Value	Std	Feature
__cpp_contracts	202502L	(C++26)	Contracts

Example

The contract_assert ensures that vector's norm is positive and either normal or subnormal.

template <std::floating_point T>
constexpr auto normalize(std::array<T, 3> vector) noexcept
    pre(/* is_normalizable(vector) */)
    post(/* vector: is_normalized(vector) */)
{
    auto& [x, y, z]{vector};
    const auto norm{std::hypot(x, y, z)};
 
    / debug check for normalization safety
    contract_assert(std::isfinite(norm) && norm > T(0);
 
    x /= norm, y /= norm, z /= norm;
 
    return vector;
}

Support status

C++26 feature	Paper(s)	GCC	Clang	MSVC	Apple Clang	EDG eccp	Intel C++	Nvidia HPC C++ (ex PGI)*	Nvidia nvcc	Cray
Contracts  (FTM)*	P2900R14

References

• C++26 standard (ISO/IEC 14882:2026):

• 8.(7+c ) Assertion statement [stmt.contract.assert]

See also

assert	aborts the program if the user-specified condition is not true. May be disabled for release builds. (function macro)
Contract assertions (C++26)	specifies properties that must hold at certain points during execution
static_assert declaration (C++11)	performs compile-time assertion checking
function contract specifiers (C++26)	specifies preconditions (pre) and postconditions (post)
[[assume(expression)]] (C++23)	specifies that the expression will always evaluate to true at a given point (attribute specifier)

Follow Lee on X/Twitter - Father, Husband, Serial builder creating AI, crypto, games & web tools. We are friends :) AI Will Come To Life!

Check out: eBank.nz (Art Generator) | Netwrck.com (AI Tools) | Text-Generator.io (AI API) | BitBank.nz (Crypto AI) | ReadingTime (Kids Reading) | RewordGame | BigMultiplayerChess | WebFiddle | How.nz | Helix AI Assistant