assert

From cppreference.com
< cpp‎ | error
 
 
 
Error handling
Exception handling
Exception handling failures
(until C++17)
(until C++17)
(C++11)(until C++17)
(until C++17)
Contracts
 
Defined in header <cassert>
#ifdef NDEBUG

#define assert(condition) ((void)0)
#else
#define assert(condition) /*implementation defined*/

#endif

The definition of the macro assert depends on another macro, NDEBUG, which is not defined by the standard library.

If NDEBUG is defined as a macro name at the point in the source code where <cassert> is included, then assert does nothing.

If NDEBUG is not defined, then assert checks if its argument (which must have scalar type) compares equal to zero. If it does, assert outputs implementation-specific diagnostic information on the standard error output and calls std::abort. The diagnostic information is required to include the text of expression, as well as the values of the standard macros __FILE__, __LINE__, and the standard variable __func__ (since C++11).

The expression assert(E) is guaranteed to be a constant subexpression, if either

  • NDEBUG is defined at the point where assert is last defined or redefined (i.e., where the header <cassert> or <assert.h> was last included); or
  • E, contextually converted to bool, is a constant subexpression that evaluates to true.
(since C++17)

Parameters

condition - expression of scalar type

Return value

(none)

Notes

Because assert is a function-like macro, commas anywhere in condition that are not protected by parentheses are interpreted as macro argument separators. Such commas are often found in template argument lists and list-initialization:

assert(std::is_same_v<int, int>); // error: assert does not take two arguments
assert((std::is_same_v<int, int>)); // OK: one argument
static_assert(std::is_same_v<int, int>); // OK: not a macro
std::complex<double> c;
assert(c == std::complex<double>{0, 0}); // error
assert((c == std::complex<double>{0, 0})); // OK

Example

#include <iostream>
// uncomment to disable assert()
// #define NDEBUG
#include <cassert>
 
int main()
{
    assert(2+2==4);
    std::cout << "Execution continues past the first assert\n";
    assert(2+2==5);
    std::cout << "Execution continues past the second assert\n";
}

Possible output:

Execution continues past the first assert
test: test.cc:10: int main(): Assertion `2+2==5' failed.
Aborted

See also

static assertion performs compile-time assertion checking (since C++11)
causes abnormal program termination (without cleaning up)
(function)