c++11 标准模板（STL）本地化库 - 平面类别（std::num_get）

本地化库

本地环境设施包含字符分类和字符串校对、数值、货币及日期/时间格式化和分析，以及消息取得的国际化支持。本地环境设置控制流 I/O 、正则表达式库和 C++ 标准库的其他组件的行为。

平面类别

从输入字符序列中解析数字值

std::num_get

template<

class CharT,
class InputIt = std::istreambuf_iterator<CharT>

> class num_get;

类 std::num_get 封装分析数值的字符串表示的规则。特别是支持类型 bool 、 unsigned short 、 unsigned int 、 long 、 unsigned long 、 long long 、 unsigned long long 、 float 、 double 、 long double 及 void* 。标准格式化输入运算符（如 cin >> n; ）用 I/O 流的 locale 的 std::num_get 平面分析数字的文本表示。

继承图

类型要求

- InputIt 必须满足遗留输入迭代器 (LegacyInputIterator) 的要求。

特化

标准库提供二个独立（不依赖本地环境）的全特化和二个部分特化：

定义于头文件 `<locale>`
std::num_get<char>	创建数字的窄字符串分析
std::num_get<wchar_t>	创建数字的宽字符串分析
std::num_get<char, InputIt>	创建数字的使用定制输入迭代器的窄字符串分析
std::num_get<wchar_t, InputIt>	创建数字的使用定制输入迭代器的宽字符串分析

另外， C++ 程序中构造的每个 locale 对象都实装这些特化的其自身（本地环境限定）版本。

成员类型

成员类型	定义
`char_type`	`CharT`
`iter_type`	`InputIt`

成员函数

(构造函数)	构造新的 num_get 平面 (公开成员函数)
(析构函数)	析构 num_get 平面 (受保护成员函数)
get	调用 `do_get` (公开成员函数)

成员对象

static std::locale::id id

locale 的 id
(公开成员对象)

受保护成员函数

do_get

[虚]

从输入流分析数字
(虚受保护成员函数)

构造新的 num_get 平面

std::num_get<CharT,InputIt>::num_get

explicit num_get( std::size_t refs = 0 );

创建 std::num_get 平面并转发引用计数 refs 到基类构造函数 locale::facet::facet() 。

参数

refs

开始的引用计数

析构 num_get 平面

std::num_get<CharT,InputIt>::~num_get

protected: ~num_get();

析构 std::num_get 平面。此析构函数为受保护且为虚（由于基类析构函数为虚）。 std::num_get 类型对象，同大多数平面，只能在最后一个实装此平面的 std::locale 离开作用域时，或若用户定义导出自 std::num_get 并实现公开构造函数，才会被销毁。

调用示例

#include <iostream>
#include <locale>

struct Destructible_num_get : public std::num_get<wchar_t>
{
    Destructible_num_get(std::size_t refs = 0) : num_get(refs) {}
    // 注意：隐式析构函数为公开
};

int main()
{
    Destructible_num_get dc;
    // std::num_get<wchar_t> c;  // 编译错误：受保护析构函数
    return 0;
}

调用 do_get & 从输入流分析数字

std::num_get<CharT,InputIt>::get, 
std::num_get<CharT,InputIt>::do_get

public: iter_type get( iter_type in, iter_type end, std::ios_base& str, std::ios_base::iostate& err, bool& v ) const;	(1)
iter_type get( iter_type in, iter_type end, std::ios_base& str, std::ios_base::iostate& err, long& v ) const;
iter_type get( iter_type in, iter_type end, std::ios_base& str, std::ios_base::iostate& err, long long& v ) const;
iter_type get( iter_type in, iter_type end, std::ios_base& str, std::ios_base::iostate& err, unsigned short& v ) const;
iter_type get( iter_type in, iter_type end, std::ios_base& str, std::ios_base::iostate& err, unsigned int& v ) const;
iter_type get( iter_type in, iter_type end, std::ios_base& str, std::ios_base::iostate& err, unsigned long& v ) const;
iter_type get( iter_type in, iter_type end, std::ios_base& str, std::ios_base::iostate& err, unsigned long long& v ) const;
iter_type get( iter_type in, iter_type end, std::ios_base& str, std::ios_base::iostate& err, float& v ) const;
iter_type get( iter_type in, iter_type end, std::ios_base& str, std::ios_base::iostate& err, double& v ) const;
iter_type get( iter_type in, iter_type end, std::ios_base& str, std::ios_base::iostate& err, long double& v ) const;
iter_type get( iter_type in, iter_type end, std::ios_base& str, std::ios_base::iostate& err, void*& v ) const;
protected: virtual iter_type do_get( iter_type in, iter_type end, std::ios_base& str, std::ios_base::iostate& err, bool& v ) const;	(2)
virtual iter_type do_get( iter_type in, iter_type end, std::ios_base& str, std::ios_base::iostate& err, long& v ) const;
virtual iter_type do_get( iter_type in, iter_type end, std::ios_base& str, std::ios_base::iostate& err, long long& v ) const;
virtual iter_type do_get( iter_type in, iter_type end, std::ios_base& str, std::ios_base::iostate& err, unsigned short& v ) const;
virtual iter_type do_get( iter_type in, iter_type end, std::ios_base& str, std::ios_base::iostate& err, unsigned int& v ) const;
virtual iter_type do_get( iter_type in, iter_type end, std::ios_base& str, std::ios_base::iostate& err, unsigned long& v ) const;
virtual iter_type do_get( iter_type in, iter_type end, std::ios_base& str, std::ios_base::iostate& err, unsigned long long& v ) const;
virtual iter_type do_get( iter_type in, iter_type end, std::ios_base& str, std::ios_base::iostate& err, float& v ) const;
virtual iter_type do_get( iter_type in, iter_type end, std::ios_base& str, std::ios_base::iostate& err, double& v ) const;
virtual iter_type do_get( iter_type in, iter_type end, std::ios_base& str, std::ios_base::iostate& err, long double& v ) const;
virtual iter_type do_get( iter_type in, iter_type end, std::ios_base& str, std::ios_base::iostate& err, void*& v ) const;

1) 公开成员函数，调用最终导出类的成员函数 do_get 。

2) 从输入迭代器 in 读取字符，并生成 v 的类型的值，考虑来自 IO 流 str.flags() 的格式化标志，来自 std::use_facet<std::ctype<charT>>(str.getloc()) 的字符分类规则，和来自 std::use_facet<std::numpunct<charT>>(str.getloc()) 的数值标点字符。此函数为所有有格式输入流运算符，如 std::cin >> n; 所调用。

转换在三个阶段出现

阶段 1 ：转换指定符选择

获得 I/O 格式化标志，如同以

fmtflags basefield = (str.flags() & std::ios_base::basefield);

fmtflags boolalpha = (str.flags() & std::ios_base::boolalpha);

若 v 的类型为整数类型，则选择下列五个选项的首个可应用者：

若 basefield == oct ，则将使用转换指定符 %o

若 basefield == hex ，则将使用转换指定符 %X

若 basefield == 0 ，则将使用转换指定符 %i

若 v 的类型有符号，则将使用转换指定符 %d

若 v 的类型无符号，则将使用转换指定符 %u

对于整数类型，若需要则添加长度指定符到转换指定：对于 short 和 unsigned short 为 h ，对于 long 和 unsigned long 为 l ，对于 long long 和 unsigned long long 为 ll
若 v 的类型为 float ，则将使用转换指定符 %g
若 v 的类型为 double ，则将使用转换指定符 %lg
若 v 的类型为 long double ，则将使用转换指定符 %Lg
若 v 的类型为 void* ，则将使用转换指定符 %p
若 v 的类型为 bool 且 boolalpha==0 ，则如同按 v 的类型为 long 一般处理，除了在阶段 3 存储于 v 的值。
若 v 的类型为 bool 且 boolalpha!=0 ，则下列规则替换阶段 2 和 3 ：
- 从输入迭代器 in 获得匹配获得自 std::use_facet<std::numpunct<charT>>(str.getloc()).falsename() 和 std::use_facet<std::numpunct<charT> >(str.getloc()).truename() 的相继字符，而且仅按需要匹配鉴别唯一匹配。仅在需要获得字符时，将输入迭代器 in 与 end 比较。
- 若目标序列为唯一匹配，则设置 v 为对应的 bool 值。否则存储 false 于 v 并赋值 std::ios_base::failbit 给 err 。若在输入结束（ in==end ）前无法找到唯一匹配，则执行 err|=std::ios_base::eofbit 。

阶段 2 ：字符释出

若 in==end ，则立即终止阶段 2 ，则不再释出更多字符
如同以 char_type ct = *in; 从 in 释出下个字符
- 若字符匹配如同用 std::use_facet<std::ctype<charT>>(str.getloc()).widen() 加宽到 locale 的 char_type 的 "0123456789abcdefxABCDEFX+-" 字符之一，则将它转换为对应的 char 。
- 若字符匹配小数点（ std::use_facet<std::numpunct<charT>>(str.getloc()).decimal_point()) ），则以 '.' 替换之。
- 若字符匹配千分隔符（ std::use_facet<std::numpunct<charT>>(str.getloc()).thousands_sep() ）且在所有 std::use_facet<std::numpunct<charT>>(str.getloc()).grouping().length() != 0 中使用千分隔，则若尚未积累小数点 '.' ，则记忆该字符的位置，但其他情况下忽略该字符。若已基类小数点，则舍弃该字符并终止阶段 2 。
- 任何情况下，检查从前一步骤获得的 char 是否在会为 std::scanf 给定阶段 1 中选择的转换指定符的输入域中得到允许。若它手允许，则将它积累到临时缓冲区并重复阶段 2 。若它不受允许，则阶段 2 终止。

阶段 3 ：转换与存储

转换阶段 2 中积累的 char 序列为数值

输入如同以 std::scanf 带阶段 1 中选择的转换指定符分析	(C++11 前)
输入如同以对 `v` 有符号整数的 std::strtoll 、对无符号整数 `v` 的 std::strtoull 或对浮点 `v` 的 std::strtold 分析	(C++11 起) (C++17 前)
输入如同以对有符号整数 `v` 的 std::strtoll 、对无符号整数 `v` 的 std::strtoull 、对 `float` `v` 的 std::strtof 、对 `double` `v` 的 std::strtod 或对 `long double` `v` 的 std::strtold 分析	(C++17 起)

若转换函数无法转换整个域，则存储值 0 于 v 。
若转换函数产生过大而无法适合 v 类型的正值，则存储可表示的最正值于 v 。
若转换函数产生过大而无法适合 v 类型的负值，则存储可表示的最负值于 v ，或对于无符号整数类型为零 (C++17 前)。

(C++11 起)

任何情况下，若转换函数失败，则赋值 std::ios_base::failbit 为 err
否则，存储转换的数值结果于 v
- 若 v 的类型为 bool 且未设置 boolalpha ，则若要存储的值为 0 则存储 false ，若要存储的值为 1 则存储 true ，对于任何其他值，赋值 std::ios_base::failbit 为 err 并存储 true 。
之后，检查数位分组。若阶段 2 中舍弃的任何千分隔符的位置不匹配 std::use_facet<std::numpunct<charT>>(str.getloc()).grouping() 所提供的分组，则赋值 std::ios_base::failbit 为 err 。
若因测试 in==end 终止阶段 2 ，则执行 err|=std::ios_base::eofbit 设置 eof 位。

返回值

in

注意

C++98/C++03 中，若出现错误，则保留 v 不更改。 C++11 中，它被设为上述的值。

C++17 前，转换负整数字符串为无符号整数曾被指定为产生零，尽管某些实现遵循了 std::strtoull 的协议，对 "-1" 给出 ULLONG_MAX ，故替而产生目标类型的最大值。 C++17 起，严格遵循 std::strtoull 是正确行为。

因为阶段 2 滤出如 'p' 、 'N' 或 'i' 的字符，如 "0x1.23p-10" 的十六进制浮点数和字符串 "NaN" 或 "inf" 可能为 do_get(double) 所拒绝，即使它们它们是对 strtod 的合法输入：此为 LWG #2381 。

调用示例 windows

#include <iostream>
#include <sstream>
#include <locale>
#include <iomanip>
#include <vector>
#include <algorithm>
#include <iterator>
#include <Windows.h>

std::vector<std::wstring> locals;

BOOL CALLBACK MyFuncLocaleEx(LPWSTR pStr, DWORD dwFlags, LPARAM lparam)
{
    locals.push_back(pStr);
    return TRUE;
}

std::string stows(const std::wstring& ws)
{
    std::string curLocale = setlocale(LC_ALL, NULL); // curLocale = "C";
    setlocale(LC_ALL, "chs");
    const wchar_t* _Source = ws.c_str();
    size_t _Dsize = 2 * ws.size() + 1;
    char *_Dest = new char[_Dsize];
    memset(_Dest, 0, _Dsize);
    wcstombs(_Dest, _Source, _Dsize);
    std::string result = _Dest;
    delete[]_Dest;
    setlocale(LC_ALL, curLocale.c_str());
    return result;
}

int main()
{
    std::string de_double = "1.234.567,89";
    std::string us_double = "1,234,567.89";

    EnumSystemLocalesEx(MyFuncLocaleEx, LOCALE_ALTERNATE_SORTS, NULL, NULL);

    for (std::vector<std::wstring>::const_iterator str = locals.begin();
            str != locals.end(); ++str)
    {
        std::cout << "The locale " << stows(*str) << ' ';

        // 流使用分析
        std::istringstream de_istringstream(de_double);
        de_istringstream.imbue(std::locale(stows(*str)));
        double double1;
        de_istringstream >> double1;

        std::istringstream us_istringstream(de_double);
        us_istringstream.imbue(std::locale(stows(*str)));
        double double2;
        us_istringstream >> double2;

        std::cout << "Parsing " << de_double << " as double gives " << std::fixed
                  << double1 << " and " << double2 << std::endl;

        // 直接使用平面
        std::istringstream istringstream(us_double);
        istringstream.imbue(std::locale(stows(*str)));
        auto& f = std::use_facet<std::num_get<char>>(istringstream.getloc());
        std::istreambuf_iterator<char> beg(istringstream), end;
        double double3;
        std::ios::iostate err;
        f.get(beg, end, istringstream, err, double3);
        std::cout << "parsing " << us_double
                  << " as double facet gives " << double3 << std::endl;
    }

    return 0;
}

输出

The locale de-DE_phoneb Parsing 1.234.567,89 as double gives 1234567.890000 and 1234567.890000
parsing 1,234,567.89 as double facet gives 1.234000
The locale es-ES_tradnl Parsing 1.234.567,89 as double gives 1234567.890000 and 1234567.890000
parsing 1,234,567.89 as double facet gives 1.234000
The locale hu-HU_technl Parsing 1.234.567,89 as double gives 1.000000 and 1.000000
parsing 1,234,567.89 as double facet gives 1.234000
The locale ja-JP_radstr Parsing 1.234.567,89 as double gives 1.234000 and 1.234000
parsing 1,234,567.89 as double facet gives 1234567.890000
The locale ka-GE_modern Parsing 1.234.567,89 as double gives 1.000000 and 1.000000
parsing 1,234,567.89 as double facet gives 1.234000
The locale x-IV_mathan Parsing 1.234.567,89 as double gives 1.234000 and 1.234000
parsing 1,234,567.89 as double facet gives 1234567.890000
The locale zh-CN_phoneb Parsing 1.234.567,89 as double gives 1.234000 and 1.234000
parsing 1,234,567.89 as double facet gives 1234567.890000
The locale zh-CN_stroke Parsing 1.234.567,89 as double gives 1.234000 and 1.234000
parsing 1,234,567.89 as double facet gives 1234567.890000
The locale zh-HK_radstr Parsing 1.234.567,89 as double gives 1.234000 and 1.234000
parsing 1,234,567.89 as double facet gives 1234567.890000
The locale zh-MO_radstr Parsing 1.234.567,89 as double gives 1.234000 and 1.234000
parsing 1,234,567.89 as double facet gives 1234567.890000
The locale zh-MO_stroke Parsing 1.234.567,89 as double gives 1.234000 and 1.234000
parsing 1,234,567.89 as double facet gives 1234567.890000
The locale zh-SG_phoneb Parsing 1.234.567,89 as double gives 1.234000 and 1.234000
parsing 1,234,567.89 as double facet gives 1234567.890000
The locale zh-SG_stroke Parsing 1.234.567,89 as double gives 1.234000 and 1.234000
parsing 1,234,567.89 as double facet gives 1234567.890000
The locale zh-TW_pronun Parsing 1.234.567,89 as double gives 1.234000 and 1.234000
parsing 1,234,567.89 as double facet gives 1234567.890000
The locale zh-TW_radstr Parsing 1.234.567,89 as double gives 1.234000 and 1.234000
parsing 1,234,567.89 as double facet gives 1234567.890000