C ++从流中提取双精度

Question

我在学校练习中遇到了一个有趣的问题。我得到了纬度和经度，我必须确保它的格式正确：\(\d+\.\d+[NS], \d\+.\d+[EW]\)。所以你可以看到我必须检查 . 有吗

char    lBracket, rBracket, comma, NS, EW;
int     nLat, nLon;
double  lat, lon;

istringstream iss ("(51.5N, 0.0E)");

iss >> fixed >> lBracket >> nLat >> lat >> NS >> comma >> 
                   nLon >> lon >> EW >> rBracket;
lat += nLat;
lon += nLon;

>> lon 提取 ".0E" 部分（这是一个有效的双精度），但我需要将其提取到 EW。

我想出的唯一解决方案是用其他字母替换 E，这可能会起作用，但不是很好的代码。

这个问题还有其他更优雅的解决方案吗？

PS: 你猜对了，不允许使用正则表达式 :D

Answer 1

您实际上是在查看解析问题。 operator>>(istream&, string&) 是一个非常简单的解析器，只对 whitespace.

进行标记

如果您的格式规范足够严格，并且您应该拒绝 (51.5N , 0.0E)（逗号前的额外 space），那么就不要提取逗号。相反，在提取后，您应该直接检查 nLat 是否包含尾随逗号并将其删除。您不再需要 >>comma.

如果您必须在任何地方支持可选的白色space，通过在逗号前后（无条件）插入额外的 space 可能有助于预处理字符串。如果已经有一个 space，现在会有两个。这没问题，因为 whitespace 跳过会跳过任何数量。

Answer 2

你的问题不是你想的那样。 .0E 不是有效的浮点数即使是科学记数法。它没有任何指数。

发生的事情是流解析器致力于解释 .0E 达到 E 时作为科学浮点数，然后找不到指数；得出结论认为其解释是错误的；将 0 分配给目标加倍并在 iss 中设置 failbit，因此不再从流是可能的。您可以通过将 0.0E 更改为 1.1E 和在尝试提取 lon. 后立即测试 iss.fail() 你会仍然发现 lon 设置为 0，而不是 0.1，并且 iss.fail() == true.

我相信在上下文中没有办法避免这种情况 w.fE（w = 整数部分，f = 小数部分）如果您尝试将 w.f 或仅 .f 提取到具有 >> 的浮点变量中。在这种特殊情况下，您已超出格式化 >> 提取的舒适区并且需要变得繁琐。事实上，这种需求并不仅仅来自 spring w.fE 极端情况，给定模式 \(\d+\.\d+[NS], \d\+.\d+[EW]\) 你告诉我们参考文献必须满足。 \d+\.\d+[NS] 部分也是 >> double >> char 或 >> [unsigned|int] >> double >> char 的严格要求：整数或浮点提取器将消耗前导 + 或 - 并且浮点提取器不会坚持存在小数点或其前后的非零位数。

解析你的地图引用的繁琐（没有正则表达式的帮助）会提示我为他们制作一个map_ref class，这样你就可以尝试提取一个 map_ref 来自输入流（可能也来自字符串）；可以问一个map_ref 无论它是好是坏（例如在尝试提取之后），并且可以插入格式化 map_ref 到输出流。

下面是这样一个 class 的草图：

#include <ostream>
#include <istream>
#include <iomanip>
#include <utility>
#include <limits>

struct map_ref
{
    map_ref() = default;
    map_ref(char NS, double lat, char EW, double lon)
    :   _NS(NS == 'N' || NS == 'S' ? NS : '?'),
        _EW(EW == 'E' || EW == 'W' ? EW : '?'),
        _lat(lat >= 0.0 && lat <= 90.0 ? lat : -1),
        _lon(lon >= 0.0 && lon <= 180.0 ? lon : -1),
        _good(_NS != '?' && _EW != '?' && _lat != -1 && _lon != -1){}

    // Todo: string ctor

    std::pair<char,double> latitude() const {
        return std::make_pair(_NS,_lat);
    }

    std::pair<char,double> longitude() const {
        return std::make_pair(_EW,_lon);
    }

    // Todo: setters, getters, equality etc.

    bool good() const {
        return _good;
    }

    bool read(std::istream & in);

    std::ostream & write(std::ostream & out, std::size_t precision = 4) const {
        return out << std::fixed << std::setprecision(precision) << 
            '(' << _lat << _NS << ", " << _lon << _EW << ')';
    }

    void clear() {
        *this = map_ref();
    }

private:
    double 
    read_fixed_point(std::istream & in, char & dest, std::string const & delims);
    char _NS = '?';
    char _EW = '?';
    double _lat = -1;
    double _lon = -1;
    bool _good = false;
};

double 
map_ref::read_fixed_point(
    std::istream & in, char & dest, std::string const & delims)
{
    std::string s;
    unsigned whole_digs = 0, frac_digs = 0;
    while(in >> dest && 
            dest != '.' && delims.find(dest) == std::string::npos)
    {
        whole_digs += std::isdigit(dest) != 0;
        s += dest;
    }
    if (dest != '.') {
        return -1;
    }
    s += dest;
    while(in >> dest && delims.find(dest) == std::string::npos)
    {
        frac_digs += std::isdigit(dest) != 0;
        s += dest;
    }
    if (whole_digs == 0 || frac_digs == 0 ||
        whole_digs + frac_digs > std::numeric_limits<double>::digits10 ||
        s.length() != 1 + whole_digs + frac_digs) {
            return -1;
    }
    return std::stod(s);
}


bool map_ref::read(std::istream & in)
{
    char lparen = 0;
    clear();
    in >> std::noskipws >> lparen;
    if (lparen != '(') {
        return _good = false;
    }
    _lat = read_fixed_point(in,_NS,"NS");
    if (_lat < 0.0 || _lat > 90.0) {
        return _good = false;
    }
    char comma = 0;
    in >> comma;
    if (comma != ',') {
        return _good = false;
    }
    while (std::isspace(in.peek())) {
        _EW = in.get();
    }
    _lon = read_fixed_point(in,_EW,"EW");
    if (_lon < 0.0 || _lon > 180.0) {
        return _good = false;
    }
    char rparen = 0;
    in >> rparen;
    return _good = rparen == ')';
}

std::istream & operator>>(std::istream & in, map_ref & mr)
{
    mr.read(in);
    return in;
}

std::ostream & operator<<(std::ostream & out, map_ref const & mr)
{
    return mr.write(out);
}

class 包含了一个明显的限制，即纬度在一个好的 map_ref 应 <= 90 北或南，经度应 <= 180 东或西。

read(std::istream &) 方法根据您的模式解析地图引用，稍微放宽一点，逗号后可以有 0 个或更多的空格。请注意，如果纬度或经度包含的数字多于无需更改即可表示的数字在 double 中（即超过 std::numeric_limits<double>::digits10 == 15)

方法：

std::ostream & write(std::ostream & out, std::size_t precision = 4)

让您指定纬度和经度的精度根据 std::set_precision(precision) 或在输出流中表示接受默认 4。如果你将它设置为 0，那么你将丢失所有小数位在输出上，所以不要那样做。

class 带有全局运算符 >> 和 << 的重载格式化提取和插入 map_refs。他们委托分别为 map_ref::read 和 map_ref::write，使用默认精度在后一种情况下;所以对于任何其他输出精度，调用 map_ref::write 直接。

对于map_ref解析的一些测试，您可以附加以下内容：

#include <iostream>
#include <sstream>

static unsigned tests = 0, pass = 0, fail = 0;

static void expect_good(char NS, double lat, char EW, double lon )
{
    std::cout << "Testing (" << ++tests << ") " 
        << NS << ',' << lat << ',' << EW << ',' << lon << '\n';
    map_ref mr(NS,lat,EW,lon);
    if (!mr.good()) {
        std::cerr << "Failed (" << tests << "): Is good, got bad\n";
        ++fail;
    } else {
        ++pass;
        std::cout << "Passed (" << tests << "): Is good. Got \"" << mr << "\"\n";  
    }
}

static void expect_bad(char NS, double lat, char EW, double lon )
{
    std::cout << "Testing (" << ++tests << ") " 
        << NS << ',' << lat << ',' << EW << ',' << lon << '\n';
    map_ref mr(NS,lat,EW,lon);
    if (mr.good()) {
        std::cerr << "Failed (" << tests << "): Is bad, got good\n";
        ++fail;
    } else {
        ++pass;
        std::cout << "Passed (" << tests << "): Is bad, got bad\n";  
    }
}

static void expect_good(std::string const & s)
{
    std::cout << "Testing (" << ++tests << ") \"" << s << "\"\n";
    std::istringstream iss(s);
    map_ref mr;
    iss >> mr;
    if (!mr.good()) {
        std::cerr << "Failed (" << tests << "): Is good, got bad\n";
        ++fail;
    } else {
        ++pass;
        std::cout << "Passed (" << tests << "): Is good. Got \"" << mr << "\"\n";  
    }
}

static void expect_bad(std::string const & s)
{
    std::cout << "Testing (" << ++tests << ") \"" << s << "\"\n";
    std::istringstream iss(s);
    map_ref mr;
    iss >> mr;
    if (mr.good()) {
        ++fail;
        std::cerr << "Failed (" << tests << "): Is bad, got good\n";
    } else {
        ++pass;
        std::cout << "Passed (" << tests << "): Is bad, got bad\n"; 
    }
}


int main()
{
    expect_bad('E',1.00,'S',1.00);
    expect_bad('N',-1.00,'W',1.00);
    expect_bad('N',90.00,'W',180.01);
    expect_bad('S',90.01,'W',180.00);
    expect_good('S',90.00,'E',180.00);
    expect_good('S',0.0,'E',0.0);
    expect_bad("");
    expect_bad("1.1N, 2.2W");
    expect_bad("(1.1N, 2.2W");
    expect_bad("1.1N, 2.2W)");
    expect_bad("[1.1N, 2.2W)");
    expect_bad("(1.1N, 2.2W(");
    expect_bad("(N)");
    expect_bad("(N, W)");
    expect_bad("(0N, 1W)");
    expect_bad("(1.0N, 2W)");
    expect_bad("(1.0N, .2W)");
    expect_bad("(.01N, 1.2E)");
    expect_bad("(1.N, 1.2W)");
    expect_bad("(N1.1, E1.2)");
    expect_bad("(1.0N, 1.2 W)");
    expect_bad("(1.0X, 1.2W)");
    expect_bad("(1.0N, 1.2Z)");
    expect_bad("(+1.0N, 1.2E)");
    expect_bad("(1.+0N, 1.2E)");
    expect_bad("(1.0N, -1.2E)");
    expect_bad("(1.0N, 1.-2E)");
    expect_bad("(1.1N, 2.3.4E)");
    expect_bad("(0.0NN, 0.0E)");
    expect_bad("(0.0N, 0.0EW)");
    expect_bad("(0.0 1N, 0.0E)");
    expect_bad("(0.01N, 0 2.0E)");
    expect_bad("(0 .01N, 2.0E)");
    expect_bad("(0.01N, 2. 0E)");
    expect_bad("(12.34567890123456N, 2.0E)");
    expect_good("(0.0N, 0.0E)");
    expect_good("(1.0N,1.2W)");
    expect_good("(01.0N,01.2W)");
    expect_good("(1.0N,  1.2W)");
    expect_good("(0.123456789N, 0.000000001E)");
    expect_good("(0.000000001S, 0.123456789W)");
    expect_good("(0.123456789N, 0.000000001W)");
    expect_good("(0.000000001S, 0.123456789E)");
    expect_good("(1.1N, 12.3456789012345E)");
    expect_bad("(0.1E, 0.1N)");
    expect_bad("(0.1W, 0.1S)");
    expect_bad("(0.1W, 0.1N)");
    expect_bad("(0.1E, 0.1S)");
    expect_good("(90.0N, 180.0E)");
    expect_good("(90.0S, 180.0W)");
    expect_good("(90.0N, 180.0W)");
    expect_good("(90.0S, 180.0E)");
    expect_bad("(90.000001N, 180.0E)");
    expect_bad("(90.000001S, 180.0W)");
    expect_bad("(90.0N, 180.000001W)");
    expect_bad("(90.0S, 180.000001E)");
    std::cout << "Tests: " << tests << std::endl;
    std::cout << "Passed: " << pass << std::endl;
    std::cout << "Failed: " << fail << std::endl;  
    return 0;
}

(gcc 4.9.2/clang 3.6, -std=c++11)

Answer 3

您可以在输入字符串中将 E 替换为 X（例如），在运行您的代码之后，您可以将 X 替换为 E 在 EW 变量中。

char    lBracket, rBracket, comma, NS, EW;
int     nLat, nLon;
double  lat, lon;

std::string inputString = "(51.5N, 0.0E)";
size_t e_pos = inputString.find( 'E' );
if ( e_pos != std::string::npos ) {
    inputString.replace( e_pos, e_pos + 1, 'X' );
}
istringstream iss ( inputString );

iss >> fixed >> lBracket >> nLat >> lat >> NS >> comma >> 
                   nLon >> lon >> EW >> rBracket;

if ( EW == 'X' ) {
    EW = 'E';
}

lat += nLat;
lon += nLon;

更新：抱歉，没看到你的留言

Only solution I came up with is replace the E with some other letter, which would probably work, but isn't really nice piece of code.

如果你想要 - 我会删除答案

C ++从流中提取双精度

c++ extracting double from stream

c++

iostream