| ## Safe Numerics

### Mixing Approaches

For purposes of exposition, we've divided the discussion of how to eliminate runtime penalties by the different approaches available. A realistic program could likely include all techniques mentioned above. Consider the following:

    #include <stdexcept>
    #include <iostream>

    #include <boost/safe_numerics/safe_integer.hpp>
    #include <boost/safe_numerics/safe_integer_range.hpp>
    #include <boost/safe_numerics/automatic.hpp>
    #include <boost/safe_numerics/exception.hpp>

    #include "safe_format.hpp" // prints out range and value of any type

    using namespace boost::safe_numerics;

    using safe_t = safe_signed_range<
        -24,
        82,
        automatic,
        loose_trap_policy
    >;

    // define variables used for input
    using input_safe_t = safe_signed_range<
        -24,
        82,
        automatic, // we don't need automatic in this case
        loose_exception_policy // assignment of out of range value should throw
    >;

    // function arguments can never be outside of limits
    auto f(const safe_t & x, const safe_t & y){
        auto z = x + y;  // we know that this cannot fail
        std::cout << "z = " << safe_format(z) << std::endl;
        std::cout << "(x + y) = " << safe_format(x + y) << std::endl;
        std::cout << "(x - y) = " << safe_format(x - y) << std::endl;
        return z;
    }

    int main(int argc, const char * argv[]){
        std::cout << "example 84:\n";
        input_safe_t x, y;
        try{
            std::cout << "type in values in format x y:" << std::flush;
            std::cin >> x >> y; // read varibles, maybe throw exception
        }
        catch(const std::exception & e){
            // none of the above should trap. Mark failure if they do
            std::cout << e.what() << std::endl;
            return 1;
        }
        std::cout << "x" << safe_format(x) << std::endl;
        std::cout << "y" << safe_format(y) << std::endl;
        std::cout << safe_format(f(x, y)) << std::endl;
        return 0;
    }

- As before, we define a type `safe_t` to reflect our view of legal values for this program. This uses the `automatic` type promotion policy as well as the `loose_trap_policy` exception policy to enforce elimination of runtime penalties.

- The function `f` accepts only arguments of type `safe_t` so there is no need to check the input values. This performs the functionality of programming by contract with no runtime cost.

- In addition, we define `input_safe_t` to be used when reading variables from the program console. Clearly, these can only be checked at runtime so they use the throw_exception policy. When variables are read from the console they are checked for legal values. We need no ad hoc code to do this, as these types are guaranteed to contain legal values and will throw an exception when this guarantee is violated. In other words, we automatically get checking of input variables with no additional programming.

- On calling of the function `f`, arguments of type `input_safe_t` are converted to values of type `safe_t` . In this particular example, it can be determined at compile time that construction of an instance of a `safe_t` from an `input_safe_t` can never fail. Hence, no `try/catch` block is necessary. The usage of the `loose_trap_policy` policy for `safe_t` types guarantees this to be true at compile time.

Here is the output from the program when values 12 and 32 are input from the console:

    example 84:
    type in values in format x y:33 45
    x<signed char>[-24,82] = 33
    y<signed char>[-24,82] = 45
    z = <short>[-48,164] = 78
    (x + y) = <short>[-48,164] = 78
    (x - y) = <signed char>[-106,106] = -12
    <short>[-48,164] = 78