Description

real_parser может анализировать реальные числа произвольной длины и размера, ограниченные параметром шаблона T. Числовой базовый тип T может быть определяемым пользователем числовым типом, таким как фиксированное_точка (фиксированные точечные реалы) и большое число (неограниченные точные числа), при условии, что тип соответствует определенным требованиям к выражению (документировано ниже).

Header

// forwards to <boost/spirit/home/qi/numeric/real.hpp>
#include <boost/spirit/include/qi_real.hpp>

Кроме того, см. Включить структуру .

Namespace

	Note
	lit повторно используется парсерами и числовыми парсерами . В общем, char parser создается, когда вы проходите в персонаже, а числовой парсер создается, когда вы используете числовой буквальный.

Synopsis

template <typename T, typename RealPolicies>
struct real_parser;

Template parameters

Model of

Expression Semantics

Семантика выражения определяется только там, где она отличается от или не определена в PrimitiveParser.

float_
double_
long_double

lit(num)
float_(num)
double_(num)
long_double(num)

real_parser<
    T, RealPolicies
>()

real_parser<
    T, RealPolicies
>()

real_parser<
    T, RealPolicies
>()(num)

Attributes

lit(num)

float_
float_(num)

double_
double_(num)

long_double
long_double(num)

real_parser<
    T, RealPolicies
>()
real_parser<
    T, RealPolicies
>()(num)

Complexity

Minimum Expression Requirements for T

Тип числового основания T, минимальные требования к выражению, перечисленные ниже, должны быть действительными. Обратите внимание, что дополнительные требования могут быть наложены таможенной политикой.

	Note
	Приведенные выше дополнительные характеристики реального числа духов позволяют пользовательским реализациям реализовывать эффективные парсеры реального числа. Например, для некоторых пользовательских реальных чисел масштабирование до базового 10 экспонента является очень дешевой операцией.

RealPolicies

Параметр шаблона RealPolicies представляет собой класс, который группирует все политики, контролирующие поведение парсера. Политика контролирует поведение парсеров реальных чисел.

По умолчанию real_policies<T>. По умолчанию обеспечивается уход за наиболее распространенным случаем (есть много способов представления и, следовательно, разбора реальных чисел). В большинстве случаев политики по умолчанию являются достаточными и могут использоваться прямо из коробки. Они предназначены для разбора чисел с плавающей точкой в стиле C/C++ формы nnn.fff, где nnn является дробной частью, fff является 'e' или 'E' и eee-' с дополнительным обнаружением NaN и Inf в соответствии со стандартом C99 и предлагаемым для включения в стандарт C++0x: nan, nan(...), inf и infinity (соответствие нечувствительно к случаю). Это соответствует следующей грамматике:

sign
    =   lit('+') | '-'
    ;
nan
    =   -lit("1.0#") >> no_case["nan"]
        >> -('(' >> *(char_ - ')') >> ')')
    ;
inf
    =   no_case[lit("inf") >> -lit("inity")]
    ;
floating_literal
    =   -sign >>
        (       nan
            |   inf
            |   fractional_constant >> -exponent_part
            |  +digit >> exponent_part
        )
    ;
fractional_constant
    =  *digit >> '.' >> +digit
    |  +digit >> -lit('.')
    ;
exponent_part
    =   (lit('e') | 'E') >> -sign >> +digit
    ;

Существует четыре RealPolicies, предопределенные для немедленного использования:

	Note
	Целые числа считаются подмножеством реальных чисел, поэтому, например, double_ также распознает целые числа (без точки). Чтобы избежать этой двусмысленности, strict_ureal_policies и strict_real_policies требуют наличия точки, чтобы число считалось успешным совпадением.

RealPolicies Expression Requirements

Для моделей RealPolicies должны быть действительны следующие выражения:

Функции parse_nan и parse_inf вызываются всякий раз, когда:

или

Первый вызов распознает представления NaN или Inf, начиная с нецифрового символа (например, NaN, Inf, QNaN и т. Д.). Второй вызов распознает форматы представления, начинающиеся с 1.0 (например, "1.0#NAN" или "1.0#INF" и т.д.).

Функции должны вернуться, если Nan или Inf были найдены. В этом случае атрибут n должен быть установлен на соответствующее значение (NaN или Inf). После этого факультативный знак будет автоматически применяться.

RealPolicies Specializations

Самый простой способ реализовать правильную политику реального разбора — вывести новый тип из типа real_policies, переопределяя аспекты разбора, которые необходимо изменить. Например, вот реализация предопределенных strict_real_policies:

template <typename T>
struct strict_real_policies : real_policies<T>
{
    static bool const expect_dot = true;
};

Example

	Note
	Испытательный ремень для примера (примеров) ниже представлен в разделе Основные примеры.

Некоторые используют декларации:

using boost::phoenix::val;
using boost::spirit::qi::double_;
using boost::spirit::qi::real_parser;
using boost::spirit::qi::lit;

Базовый анализ реальных чисел:

// double
test_parser("+12345e6", double_);
test_parser("-12345e6", double_);
test_parser("+12345e6", double_(12345e6));
test_parser("-12345e6", double_(-123456e6));
test_parser("+12345e6", double_(val(12345e6)));
test_parser("-12345e6", double_(val(-123456e6)));
// literals
test_parser("+12345e6", lit(12345e6));
test_parser("-12345e6", lit(-123456e6));
test_parser("+12345e6", lit(val(12345e6)));
test_parser("-12345e6", lit(val(-123456e6)));

Правила реального номера:

///////////////////////////////////////////////////////////////////////////////
//  These policies can be used to parse thousand separated
//  numbers with at most 2 decimal digits after the decimal
//  point. e.g. 123,456,789.01
///////////////////////////////////////////////////////////////////////////////
template <typename T>
struct ts_real_policies : boost::spirit::qi::ureal_policies<T>
{
    //  2 decimal places Max
    template <typename Iterator, typename Attribute>
    static bool
    parse_frac_n(Iterator& first, Iterator const& last, Attribute& attr)
    {
        return boost::spirit::qi::
            extract_uint<T, 10, 1, 2, true>::call(first, last, attr);
    }
    //  No exponent
    template <typename Iterator>
    static bool
    parse_exp(Iterator&, Iterator const&)
    {
        return false;
    }
    //  No exponent
    template <typename Iterator, typename Attribute>
    static bool
    parse_exp_n(Iterator&, Iterator const&, Attribute&)
    {
        return false;
    }
    //  Thousands separated numbers
    template <typename Iterator, typename Attribute>
    static bool
    parse_n(Iterator& first, Iterator const& last, Attribute& attr)
    {
        using boost::spirit::qi::uint_parser;
        namespace qi = boost::spirit::qi;
        uint_parser<unsigned, 10, 1, 3> uint3;
        uint_parser<unsigned, 10, 3, 3> uint3_3;
        T result = 0;
        if (parse(first, last, uint3, result))
        {
            bool hit = false;
            T n;
            Iterator save = first;
            while (qi::parse(first, last, ',') && qi::parse(first, last, uint3_3, n))
            {
                result = result * 1000 + n;
                save = first;
                hit = true;
            }
            first = save;
            if (hit)
                attr = result;
            return hit;
        }
        return false;
    }
};

И его использование:

real_parser<double, ts_real_policies<double> > ts_real;
test_parser("123,456,789.01", ts_real);
test_parser("123,456,789.01", ts_real(123456789.01));