Edit: чтобы избежать использования структуры обертки вокруг двойника, я заключаю istream вместо этого в классе оболочки.

к сожалению, я не могу понять, как избежать двусмысленности, созданной добавлением другого метода ввода для double. Для реализации ниже, я создал структуру оболочку вокруг istream, и класс-оболочка реализует метод ввода. Метод ввода определяет отрицательность, затем пытается извлечь double. Если это не удается, начинается разбор.

Edit: спасибо sehe за то, что заставил меня проверить условия ошибок лучше.

struct double_istream {
    std::istream ∈

    double_istream (std::istream &i) : in(i) {}

    double_istream & parse_on_fail (double &x, bool neg);

    double_istream & operator >> (double &x) {
        bool neg = false;
        char c;
        if (!in.good()) return *this;
        while (isspace(c = in.peek())) in.get();
        if (c == '-') { neg = true; }
        in >> x;
        if (! in.fail()) return *this;
        return parse_on_fail(x, neg);
    }
};

процедура синтаксического анализа была немного сложнее реализовать, чем я сначала думал, но я хотел избежать попыток putback всю строку.

double_istream &
double_istream::parse_on_fail (double &x, bool neg) {
    const char *exp[] = { "", "inf", "NaN" };
    const char *e = exp[0];
    int l = 0;
    char inf[4];
    char *c = inf;
    if (neg) *c++ = '-';
    in.clear();
    if (!(in >> *c).good()) return *this;
    switch (*c) {
    case 'i': e = exp[l=1]; break;
    case 'N': e = exp[l=2]; break;
    }
    while (*c == *e) {
        if ((e-exp[l]) == 2) break;
        ++e; if (!(in >> *++c).good()) break;
    }
    if (in.good() && *c == *e) {
        switch (l) {
        case 1: x = std::numeric_limits<double>::infinity(); break;
        case 2: x = std::numeric_limits<double>::quiet_NaN(); break;
        }
        if (neg) x = -x;
        return *this;
    } else if (!in.good()) {
        if (!in.fail()) return *this;
        in.clear(); --c;
    }
    do { in.putback(*c); } while (c-- != inf);
    in.setstate(std::ios_base::failbit);
    return *this;
}

одно отличие в поведении эта процедура будет иметь по умолчанию double вход является то, что - символ не используется, если вход был, например "-inp". О неудаче,"-inp" все еще будет в потоке для double_istream, но для обычного istream только "inp" останется в потоке.

std::istringstream iss("1.0 -NaN inf -inf NaN 1.2");
double_istream in(iss);
double u, v, w, x, y, z;
in >> u >> v >> w >> x >> y >> z;
std::cout << u << " " << v << " " << w << " "
          << x << " " << y << " " << z << std::endl;

вывод вышеуказанного фрагмента в моей системе:

1 nan inf -inf nan 1.2

Edit: добавление" iomanip", как вспомогательный класс. А double_imanip объект будет действовать как переключатель, когда он появляется более одного раза в .

struct double_imanip {
    mutable std::istream *in;
    const double_imanip & operator >> (double &x) const {
        double_istream(*in) >> x;
        return *this;
    }
    std::istream & operator >> (const double_imanip &) const {
        return *in;
    }
};

const double_imanip &
operator >> (std::istream &in, const double_imanip &dm) {
    dm.in = ∈
    return dm;
}

а затем следующий код, чтобы попробовать out:

std::istringstream iss("1.0 -NaN inf -inf NaN 1.2 inf");
double u, v, w, x, y, z, fail_double;
std::string fail_string;
iss >> double_imanip()
    >> u >> v >> w >> x >> y >> z
    >> double_imanip()
    >> fail_double;
std::cout << u << " " << v << " " << w << " "
          << x << " " << y << " " << z << std::endl;
if (iss.fail()) {
    iss.clear();
    iss >> fail_string;
    std::cout << fail_string << std::endl;
} else {
    std::cout << "TEST FAILED" << std::endl;
}

вывод из вышеперечисленного:

1 nan inf -inf nan 1.2
inf

редактировать из Drise: я сделал несколько изменений, чтобы принять такие варианты, как Inf и nan, которые изначально не были включены. Я также превратил его в скомпилированную демонстрацию, которую можно просмотреть по адресу http://ideone.com/qIFVo.