converter<> function object

namespace boost { namespace numeric {
    template<class T,
             class S,
             class Traits,          = conversion_traits<T,S>
             class OverflowHandler  = def_overflow_handler,
             class Float2IntRounder = Trunc< typename Traits::source_type >,
             class RawConverter     = raw_converter<Traits>,
             class UserRangeChecker = UseInternalRangeChecker
            >
    struct converter
    {
        typedef Traits traits ;
        typedef typename Traits::source_type   source_type   ;
        typedef typename Traits::argument_type argument_type ;
        typedef typename Traits::result_type   result_type   ;
        static result_type convert ( argument_type s ) ;
        result_type operator() ( argument_type s ) const ;
        // Internal member functions:
        static range_check_result out_of_range      ( argument_type s ) ;
        static void               validate_range    ( argument_type s ) ;
        static result_type        low_level_convert ( argument_type s ) ;
        static source_type        nearbyint         ( argument_type s ) ;
    } ;
} } // namespace numeric, boost

boost::::конвертер<> представляет собой Unary Function Object, инкапсулирующий код для выполнения численного преобразования с направлением и свойствами, указанными параметром шаблона Traits. Он может необязательно принимать некоторые политики , которые могут быть использованы для настройки его поведения. Параметр Traits — это не политика, а параметр, определяющий конверсию.

Эта статическая функция преобразует rзначение типа source_type в rзначение типа target_type.

Если конверсия требует этого, она выполняет проверку диапазона перед конверсией и передает результат проверки в политику обработчика переполнения (политика по умолчанию выбрасывает исключение, если обнаружен вне диапазона)

Реализация этой функции фактически строится на основе политики и в основном заключается в следующем:

result_type converter<>::convert ( argument_type s )
{
    validate_range(s); // Implemented by the internal range checking logic
                       // (which also calls the OverflowHandler policy)
                       // or externally supplied by the UserRangeChecker policy.
    s = nearbyint(s); // Externally supplied by the Float2IntRounder policy.
                      // NOTE: This is actually called only for float to int conversions.
    return low_level_convert(s); // Externally supplied by the RawConverter policy.
}

конвертер<>::оператор() конст просто вызывает конверт()

Эта функция внутреннего статического элемента определяет, может ли значение s быть представлено целевым типом без переполнения.

Он не определяет, является ли преобразование точным; то есть он не обнаруживает неточнымконверсий, только вне диапазонаконверсий (см. Определения для более подробной информации).

Возвратное значение имеет числовой тип boost::numeric::range_check_result

Фактический код для логики проверки диапазона оптимизирован для комбинированных свойств исходного и целевого типов. Например, несубранжированное преобразование (т.е. int->float) не требует проверки диапазона, поэтому out_of_range() возвращает cInRange напрямую. Подробнее см. ниже table.

Если пользователь предоставил политику UserRangeChecker, то эта политика реализует эту функцию, поэтому реализация определяется пользователем, хотя ожидается, что она выполнит ту же концептуальную проверку и вернет соответствующий результат.

Эта функция внутреннего статического члена вызывает_of_range(s) и передает результат в класс политики OverflowHandler.

Для тех комбинаций Target/Source, которые не требуют проверки диапазона, это пустая встроенная функция.

Если пользователь предоставил политику UserRangeChecker, это политика, которая реализует эту функцию, поэтому реализация определена пользователем, хотя ожидается, что она будет выполнять то же действие, что и по умолчанию. В частности, ожидается передача результата проверки обработчику переполнения.

Эта функция внутреннего статического элемента выполняет фактическое преобразование.

Эта функция подается извне классом политики RawConverter.

Эта функция внутреннего статического элемента, которая используется только для плавающего для инт преобразований, возвращает целое число значение плавающего типа в соответствии с некоторым направлением округления.

Эта функция внешне поставляется классом политики Float2IntRounder, который инкапсулирует конкретный режим округления.

Internal Member Functions

Эти статические функции-члены строят фактический код преобразования, используемый , преобразуют(). При вызове конвертировать() пользователю не нужно их вызывать, поскольку конвертировать() вызывает их инферно, но их можно вызывать отдельно для конкретных нужд.

В приведенной ниже таблице обобщена внутренняя логика проверки диапазона, выполняемая для каждой комбинации свойств Источника и Цели.

Самый низкий / самый высокий T обозначает самые высокие и самые низкие значения типа Target соответственно.

S(n) сокращение от static_cast<S>(n) (S обозначает тип Источника).

NONE указывает на то, что для этого случая нет проверки диапазона.

int_to_int    |--> sig_to_sig     |--> subranged     |--> ( s >= S(LowestT) ) && ( s <= S(HighestT) )
              |                   |--> not subranged |--> NONE
              |
              |--> unsig_to_unsig |--> subranged     |--> ( s >= S(LowestT) ) && ( s <= S(HighestT) )
              |                   |--> not subranged |--> NONE
              |
              |--> sig_to_unsig   |--> pos subranged     |--> ( s >= S(0) ) && ( s <= S(HighestT) )
              |                   |--> not pos subranged |--> ( s >= S(0) )
              |
              |--> unsig_to_sig   |--> subranged     |--> ( s <= S(HighestT) )
              |                   |--> not subranged |--> NONE


int_to_float   |--> NONE


float_to_int   |--> round_to_zero         |--> ( s >  S(LowestT)-S(1)   ) && ( s <  S(HighestT)+S(1)   )
               |--> round_to_even_nearest |--> ( s >= S(LowestT)-S(0.5) ) && ( s <  S(HighestT)+S(0.5) )
               |--> round_to_infinity     |--> ( s >  S(LowestT)-S(1)   ) && ( s <= S(HighestT)        )
               |--> round_to_neg_infinity |--> ( s >= S(LowestT)        ) && ( s <  S(HighestT)+S(1)   )


float_to_float |--> subranged     |--> ( s >= S(LowestT) ) && ( s <= S(HighestT) )
               |--> not subranged |--> NONE

#include <cassert>
#include <boost/numeric/conversion/converter.hpp>
int main() {
    typedef boost::numeric::converter<int,double> Double2Int ;
    int x = Double2Int::convert(2.0);
    assert ( x == 2 );
    int y = Double2Int()(3.14); // As a function object.
    assert ( y == 3 ) ; // The default rounding is trunc.
    try
    {
        double m = boost::numeric::bounds<double>::highest();
        int z = Double2Int::convert(m); // By default throws positive_overflow()
    }
    catch ( boost::numeric::positive_overflow const& )
    {
    }
    return 0;
}