Jak uzyskać wszystkie wyniki kompilatora platformy dla tego samego ciągu dla NaN?

Question

Rozważmy następujący fragment kodu:

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

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

Kiedy skompilowany z Visual Studio 2010, wyjście jest 1.#QNAN. Gdy skompilowane z g ++, wyjście to nan. Zwróć uwagę, że Visual Studio 2015 wyświetla "nan".

Potrzebuję jednak obu tych samych wyników. Jaki jest najprostszy sposób to zrobić? Próbowałem zastąpić operator<< dla double, ale wydaje mi się, że nie jest to właściwy sposób. Czy ciąg może być użyty dla wartości NaN wartość być wymuszona na poziomie stream, lub lepiej, na poziomie globalnym (używając std::locale rzeczy? ... nigdy nie używane, że ...).

Znalazłem ten przykład squaring_num_put. Interesujące, ponieważ jest to sposób modyfikowania liczby, jest przekierowywany na wyjście. Ale ciężko mi próbować dostosować go do mojego problemu (nie można ustawić, aby do_put wysyłał albo numer, albo zakodowany ciąg "NaN" do ostream ...).

Answer 1

Można używać strumienia manipulator lub zmodyfikować podstawową regionalne:

Manipulator:

#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'; 

} 

Locale:

#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 2

Wystarczy zaimplementować własne sprawdzenie względem wartości quiet_NaN i wydrukować na tej podstawie.

Answer 3

Użyj isnan(), aby testować przenośnie, czy double jest NaN.

#include <cmath> 

// ... 

double d; 

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

Answer 4

• Wyprowadź swoją YourNumPut z std::num_put.
• Zastąp co trzeba na przykład: virtual iter_type do_put(iter_type out, std::ios_base& str, char_type fill, double v) const;
• Tworzenie locale, który używa go: std::locale yourLocale(std::locale(), new YourNumPut());

• Set to globalny nasycić cout i cerr lub gdzie trzeba: std::locale::global(yourLocale); std::cout.imbue(yourLocale); std::cerr.imbue(yourLocale);

• testowy to

• ...
• Zysk;)