ckd_sub

 

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

 

Numerics library

Common mathematical functions
Mathematical special functions (C++17)
Mathematical constants (C++20)
Basic linear algebra algorithms (C++26)
Data-parallel types (SIMD) (C++26)
Floating-point environment (C++11)
Complex numbers
Numeric array (valarray)
Pseudo-random number generation
Bit manipulation (C++20)
Saturation arithmetic (C++26)
Factor operations
gcd (C++17)	lcm (C++17)
Interpolations
midpoint (C++20)	lerp (C++20)
Generic numeric operations
iota (C++11) ranges::iota (C++23) accumulate inner_product adjacent_difference      partial_sum	reduce (C++17) transform_reduce (C++17) inclusive_scan (C++17) exclusive_scan (C++17) transform_inclusive_scan (C++17) transform_exclusive_scan (C++17)
C-style checked integer arithmetic
ckd_add (C++26) ckd_sub (C++26)	ckd_mul (C++26)

 

Defined in header <stdckdint.h>
template< class type1, class type2, class type3 > bool ckd_sub( type1* result, type2 a, type3 b );		(since C++26)

See More

Computes the subtraction x - y and stores the result into *result. The subtraction is performed as if both operands were represented in a signed integer type with infinite range, and the result was then converted from this integer type to type1. If the value assigned to *result correctly represents the mathematical result of the operation, it returns false. Otherwise, it returns true. In this case, the value assigned to *result is the mathematical result of the operation wrapped around to the width of *result.

Parameters

a, b	-	integer values
result	-	address of where result should be stored

Return value

false if the value assigned to *result correctly represents the mathematical result of the subtraction, true otherwise.

Note

The function template ckd_sub has the same semantics as the corresponding type-generic macro with the same name specified in C23.

Each of the types type1, type2, and type3 is a cv-unqualified signed or unsigned integer type.

It is recommended to produce a diagnostic message if type2 or type3 are not suitable integer types, or if *result is not a modifiable lvalue of a suitable integer type.

Example

Run this code

#include <cstdint>
#include <limits>
#include <print>
#include <stdckdint.h>

int main()
{
    int16_t result1{};
    constexpr std::int8_t x1{-2};
    constexpr std::int16_t y1{1};
    const bool underflow1{ckd_sub(&result1, x1, y1)};
    std::println("{} - {} == {} ({})", x1, y1, result1, underflow1 ? "Underflow" : "OK");

    int16_t result2{};
    constexpr std::int8_t x2{-2};
    constexpr std::int16_t y2{std::numeric_limits<std::int16_t>::max()};
    const bool underflow2{ckd_sub(&result2, x2, y2)};
    std::println("{} - {} == {} ({})", x2, y2, result2, underflow2 ? "Underflow" : "OK");

    int32_t result3{};
    constexpr std::int8_t x3{-2};
    constexpr std::int16_t y3{std::numeric_limits<std::int16_t>::max()};
    const bool underflow3{ckd_sub(&result3, x3, y3)};
    std::println("{} - {} == {} ({})", x3, y3, result3, underflow3 ? "Underflow" : "OK");
}

Output:

-2 - 1 == -3 (OK)
-2 - 32767 == 32767 (Underflow)
-2 - 32767 == -32769 (OK)

References

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

• 29.11.2 Checked integer operations

See also

ckd_add (C++26)	checked addition operation on two integers (function template)
ckd_mul (C++26)	checked multiplication operation on two integers (function template)
C documentation for ckd_sub