如何让所有平台编译器为 NaN 输出相同的字符串？

Question

考虑这个代码片段：

#include <iostream>
#include <string>
#include <limits>

int main()
{
    std::cout << std::numeric_limits<double>::quiet_NaN();
}

使用 Visual Studio 2010 编译时，输出为 1.#QNAN。使用 g++ 编译时，输出为 nan。请注意 Visual Studio 2015 输出 "nan".

但是，我需要两者才能产生相同的输出。最简单的方法是什么？我试图为 double 覆盖 operator<<，但我觉得这不是正确的做法。可以将用于 NaN 值的字符串强制设置为 stream 级别，或者更好，在全局级别（使用 std::locale 东西？...从未使用过...）。

我找到了这个 squaring_num_put 示例。有趣的是，它是一种将修改数字重定向到输出的方法。但是我很难让它适应我的问题（无法让 do_put 发送数字或硬编码的 "NaN" 字符串到 ostream...）。

Answer 1

只需根据 quiet_NaN 值执行您自己的检查，并根据该值进行打印。

Answer 2

使用 isnan() 可移植地测试 double 是否为 NaN。

#include <cmath>

// ...

double d;

if (isnan(d))
   // ...

Answer 3

从 std::num_put 推导出你的 YourNumPut。
覆盖您需要的内容，例如：virtual iter_type do_put( iter_type out, std::ios_base& str, char_type fill, double v ) const;
创建使用它的语言环境：std::locale yourLocale(std::locale(), new YourNumPut());
将其设置为全局，灌输 cout 和 cerr 或您需要的地方：std::locale::global(yourLocale); std::cout.imbue(yourLocale); std::cerr.imbue(yourLocale);
测试一下
...
利润 ;)

Answer 4

您可以使用流操纵器或修改底层语言环境：

操纵者：

#include <cmath>
#include <ostream>

template <typename T>
struct FloatFormat
{
    const T value;

    FloatFormat(const T& value)
    : value(value)
    {}

    void write(std::ostream& stream) const {
        if(std::isnan(value))
            stream << "Not a Number";
        else
            stream << value;
    }
};

template <typename T>
inline FloatFormat<T> float_format(const T& value) {
    return FloatFormat<T>(value);
}

template <typename T>
inline std::ostream& operator << (std::ostream& stream, const FloatFormat<T>& value) {
    value.write(stream);
    return stream;
}

int main() {
    std::cout << float_format(std::numeric_limits<double>::quiet_NaN()) << '\n';

}

语言环境：

#include <cmath>
#include <locale>
#include <ostream>

template<typename Iterator = std::ostreambuf_iterator<char>>
class NumPut : public std::num_put<char, Iterator>
{
    private:
    using base_type = std::num_put<char, Iterator>;

    public:
    using char_type = typename base_type::char_type;
    using iter_type = typename base_type::iter_type;

    NumPut(std::size_t refs = 0)
    :   base_type(refs)
    {}

    protected:
    virtual iter_type do_put(iter_type out, std::ios_base& str, char_type fill, double v) const override {
        if(std::isnan(v))
            out = std::copy(std::begin(NotANumber), std::end(NotANumber), out);
        else
            out = base_type::do_put(out, str, fill, v);
        return out;
    }

    virtual iter_type do_put(iter_type out, std::ios_base& str, char_type fill, long double v) const override {
        if(std::isnan(v))
            out = std::copy(std::begin(NotANumber), std::end(NotANumber), out);
        else
            out = base_type::do_put(out, str, fill, v);
        return out;
    }

    private:
    static const char NotANumber[];
};

template<typename Iterator>
const char NumPut<Iterator>::NotANumber[] = "Not a Number";

#include <iostream>
#include <limits>

int main() {
    #if 1
    {
        const std::size_t NoDestroy = 1;
        NumPut<> num_put(NoDestroy);
        std::locale locale(std::cout.getloc(), &num_put);
        std::locale restore_locale = std::cin.getloc();
        std::cout.imbue(locale);
        std::cout << std::numeric_limits<double>::quiet_NaN() << '\n';
        // The num_put facet is going out of scope:
        std::cout.imbue(restore_locale);
    }
    #else
    {
        // Alternitvely use a reference counted facet and pass the ownership to the locales:
        auto num_put = new NumPut<>();
        std::locale locale(std::cout.getloc(), num_put);
        std::cout.imbue(locale);
        std::cout << std::numeric_limits<double>::quiet_NaN() << '\n';
    }
    #endif
    std::cout << std::numeric_limits<double>::quiet_NaN() << '\n';
}

Answer 5

在 C++20 中，您将能够使用 std::format 来执行此操作：

std::cout << std::format("{}", std::numeric_limits<double>::quiet_NaN());

这将在所有具有 quiet_NaN 的平台上打印 nan。

免责声明：我是 C++20 的作者std::format。

如何让所有平台编译器为 NaN 输出相同的字符串？

How to have all platform compiler output the same string for NaN?

c++

nan

ostream