Boost C++ Libraries of the most highly regarded and expertly designed C++ library projects in the world. Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

This is the documentation for an old version of Boost. Click here to view this page for the latest version.
Library Documentation Index

Safe Numerics


safe_signed_range<MIN, MAX, PP, EP> and safe_unsigned_range<MIN, MAX, PP, EP>

Associated Types
Template Parameters
Model of
Valid Expressions
Example of use


This type holds a signed or unsigned integer in the closed range [MIN, MAX]. A safe_signed_range<MIN, MAX, PP, EP> or safe_unsigned_range<MIN, MAX, PP, EP> can be used anywhere an arithmetic type is permitted. Any expression which uses either of these types is guaranteed to return an arithmetically correct value or to trap in some way.


Symbol Description
MIN, MAX Minimum and maximum values that the range can represent.

Associated Types

PP Promotion Policy. A type which specifies the result type of an expression using safe types.
EP Exception Policy. A type containing members which are called when a correct result cannot be returned

Template Parameters

Parameter Requirements Description
MIN must be a non-negative literal The minimum non-negative integer value that this type may hold
MAX must be a non-negative literal The maximum non-negative integer value that this type may hold
  MIN <= MAX must be a valid closed range
PP PromotionPolicy<PP>

Default value is boost::numeric::native

EP Exception Policy<EP>

Default value is boost::numeric::default_exception_policy

Model of



Valid Expressions

Implements all expressions and only those expressions defined by the SafeNumeric type requirements. Thus, the result type of such an expression will be another safe type. The actual type of the result of such an expression will depend upon the specific promotion policy template parameter.

Example of use

#include <type_traits>
#include <boost/safe_numerics/safe_integer.hpp>
#include <boost/safe_numerics/safe_integer_range.hpp>

#include <boost/safe_numerics/utility.hpp>

using namespace boost::safe_numerics;

void f(){
    safe_unsigned_range<7, 24> i;
    // since the range is included in [0,255], the underlying type of i 
    // will be an unsigned char.
    i = 0;  // throws out_of_range exception
    i = 9;  // ok
    i *= 9; // throws out_of_range exception
    i = -1; // throws out_of_range exception
    std::uint8_t j = 4;
    auto k = i + j;

    // if either or both types are safe types, the result is a safe type
    // determined by promotion policy.  In this instance
    // the range of i is [7, 24] and the range of j is [0,255].
    // so the type of k will be a safe type with a range of [7,279]
        && std::numeric_limits<decltype(k)>::min() == 7
        && std::numeric_limits<decltype(k)>::max() == 279,
        "k is a safe range of [7,279]"

int main(){}


#include <boost/numeric/safe_numerics/safe_range.hpp>