A safe type which holds a literal value. This is required to be able to initialize other safe types in such a way that an exception code is not generated. It is also useful when creating constexpr versions of safe types. It contains one immutable value known at compile time and hence can be used in any constexpr expression.

Numeric

Integer

safe literal types are immutable. Hence they only inherit those valid expressions which don't change the value. This excludes assignment, increment, and decrement and all unary operators except unary -, + and ~. Other than that, they can be used anywhere a Value type can be used. Note that the default promotion and exception policies are void. This is usually convenient since when a safe literal is used in a binary operation, this will inherit the policies of the other type. On the other hand, this can be inconvenient when operands of a binary expression are both safe literals. This will fail to compile since there are no designated promotion and exception policies. The way to address this to assign specific policies as in this example.

template<typename T>
using compile_time_value = safe_signed_literal<T>;

constexpr compile_time_value<1000> x;
constexpr compile_time_value<0> y;

// should compile and execute without problem
    
std::cout << x << '\n';

// all the following statements should fail to compile because there are 
// no promotion and exception policies specified.
constexpr safe<int> z = x / y;

#include <boost/safe_numerics/safe_integer_literal.hp>

constexpr boost::safe_numerics::safe_signed_literal<42> x;

This is a macro which returns an instance of a safe literal type. This instance will hold the value n. The type of the value returned will be the smallest safe type which can hold the value n.

#include <boost/safe_numerics/safe_integer_literal.hpp>