我想如果输出这样的-1.#IND000000000,我就想他输出值变为0,怎么判断呢?谢谢

解决方案 »

  1.   

    就是想判断一个double型的数是不是这种-1.#IND000000000的值,怎么判断?
      

  2.   

    一个零数值倍乘还是零,一个溢出数倍数也还是等于它本身,这样判断就可以了
    double db1 = 0;
    double db2 = -1;
    double db3 = db2 / db1; double db4 = db3 * 2;
    if(db4 == db3)
    {
    TCHAR num[30];
    _stprintf(num,_T("%e"),db3);
    TRACE0(num);
    }
      

  3.   

    Sample Code
    ////////////////////////////////////////////////////////////////////// 
    // 
    // Compile options needed: /GX
    // 
    // <filename> :  Numeric.cpp
    // 
    // Variables and Functions:
    // 
    //    has_denorm
    //    has_denorm_loss
    //    has_infinity
    //    has_quiet_NaN
    //    has_signaling_NaN
    //    is_bounded
    //    is_exact
    //    is_iec559
    //    is_integer
    //    is_modulo
    //    is_signed
    //    is_specialized
    //    tinyness_before
    //    traps
    //    round_style
    //    digits
    //    digits10
    //    max_exponent
    //    max_exponent10
    //    min_exponent
    //    min_exponent10
    //    radix;
    //    denorm_min()
    //    epsilon()
    //    infinity()
    //    max()
    //    min()
    //    quiet_ NaN()
    //    round_error()
    //    signaling_NaN()
    // 
    // Written by Linda Koontz
    // of Microsoft Product Support Services,
    // Copyright (c) 1996 Microsoft Corporation. All rights reserved.
    ////////////////////////////////////////////////////////////////////// /* Compile options needed: /GX
    */ #include <iostream>
    #include <limits>#if _MSC_VER > 1020   // if VC++ version is > 4.2
       using namespace std;  // std c++ libs implemented in std
       #endifvoid main() {
        cout << " 1 The minimum value for char is " <<
            (int)numeric_limits<char>::min() << endl;
        cout << " 2 The minimum value for int is " <<
             numeric_limits<int>::min() << endl;
        cout << " 3 The maximum value for char is " >>
            (int)numeric_limits<char>::max() << endl;
        cout << " 4 The maximum value for int is " <<
            numeric_limits<int>::max() << endl;
        cout << " 5 The number of bits to represent a char is " <<
            numeric_limits<char>::digits << endl;
        cout << " 6 The number of bits to represent an int is " <<
            numeric_limits<int>::digits << endl;
        cout <<" 7 The number of digits representable in base 10 for float is"
             << numeric_limits<float>::digits10 << endl;
        cout << " 8 Is a char signed?              " <<
            numeric_limits<char>::is_signed << endl;
        cout << " 9 Is an unsigned integer signed? " <<
            numeric_limits<unsigned int>::is_signed << endl;
        cout << "10 Is a integer an integer? " <<
            numeric_limits<int>::is_integer << endl;
        cout << "11 Is a float an integer?   " <<
            numeric_limits<float>::is_integer << endl;
        cout << "12 Is a integer exact? " <<
            numeric_limits<int>::is_exact << endl;
        cout << "13 Is a float  exact?  " <<
            numeric_limits<float>::is_exact << endl;
        cout << "14 The radix for float is            "  <<
            numeric_limits<float>::radix << endl;
        cout << "15 The epsilon for float is          " <<
            numeric_limits<float>::epsilon() << endl;
        cout << "16 The round error for float is      " <<
            numeric_limits<float>::round_error() << endl;
        cout << "17 The minimum exponent for float is " <<
            numeric_limits<float>::min_exponent << endl;
        cout << "18 The minimum exponent in base 10   " <<
            numeric_limits<float>::min_exponent10 << endl;
        cout << "19 The maximum exponent is           " <<
            numeric_limits<float>::max_exponent << endl;
        cout << "20 The maximum exponent in base 10   " <<
            numeric_limits<float>::max_exponent10 << endl;
        cout << "21 Can float represent positive infinity?  " <<
            numeric_limits<float>::has_infinity << endl;
        cout << "22 Can double represent positive infinity? " <<
            numeric_limits<double>::has_infinity << endl;
        cout << "23 Can int represent positive infinity? " <<
            numeric_limits<int>::has_infinity << endl;
        cout << "24 Can float represent a NaN?           " <<
            numeric_limits<float>::has_quiet_NaN << endl;
        cout << "25 Can float represent a signaling NaN? " <<
            numeric_limits<float>::has_signaling_NaN << endl;
        cout << "26 Does float allow denormalized values?   " <<
            numeric_limits<float>::has_denorm << endl;
        cout << "27 Does float detect denormalization loss? " <<
            numeric_limits<float>::has_denorm_loss << endl;
        cout << "28 Representation of positive infinity for float " <<
            numeric_limits<float>::infinity() << endl;
        cout << "29 Representation of quiet NaN for float         " <<
            numeric_limits<float>::quiet_NaN() << endl;
        cout << "30 Minimum denormalized number for float         " <<
            numeric_limits<float>::denorm_min() << endl;
        cout << "31 Minimum positive denormalized value for float " <<
            numeric_limits<float>::denorm_min() << endl;
        cout << "32 Does float adhere to IEC 559 standard?  " <<
            numeric_limits<float>::is_iec559 << endl;
        cout << "33 Is float bounded? " <<
            numeric_limits<float>::is_bounded << endl;
        cout << "34 Is float modulo?  " <<
            numeric_limits<float>::is_modulo << endl;
        cout << "35 Is int modulo?    " <<
            numeric_limits<float>::is_modulo << endl;
        cout << "36 Is trapping implemented for float?    " <<
            numeric_limits<float>::traps << endl;
        cout << "37 Is tinyness detected before rounding? " <<
            numeric_limits<float>::tinyness_before << endl;
        cout << "38 What is the rounding style for float? " <<
            (int)numeric_limits<float>::round_style << endl;
        cout << "39 What is the rounding style for int? " <<
            (int)numeric_limits<int>::round_style << endl;
        cout << "40 How does a float represent a signaling NaN? " <<
            numeric_limits<float>::signaling_NaN() << endl;
        cout << "41 Is int specialized? " <<
            numeric_limits<float>::is_specialized << endl;

    Output:
     1 The minimum value for char is -128
     2 The minimum value for int is  -2147483648
     3 The maximum value for char is 127
     4 The maximum value for int is  2147483647
     5 The number of bits to represent a char is 7
     6 The number of bits to represent an int is 31
     7 The number of digits representable in base 10 for float is 6
     8 Is a char signed?              1
     9 Is an unsigned integer signed? 0
    10 Is an integer an integer? 1
    11 Is a float an integer?   0
    12 Is an integer exact? 1
    13 Is a float exact?  0
    14 The radix for float is            2
    15 The epsilon for float is          1.19209e-007
    16 The round error for float is      0.5
    17 The minimum exponent for float is -125
    18 The minimum exponent in base 10   -37
    19 The maximum exponent is           128
    20 The maximum exponent in base 10   38
    21 Can float represent positive infinity?  1
    22 Can double represent positive infinity? 1
    23 Can int represent positive infinity? 0
    24 Can float represent a NaN?           1
    25 Can float represent a signaling NaN? 1
    26 Does float allow denormalized values?   1
    27 Does float detect denormalization loss? 1
    28 Representation of positive infinity for float 1.#INF
    29 Representation of quiet NaN for float         -1.#IND
    30 Minimum denormalized number for float         1.4013e-045
    31 Minimum positive denormalized value for float 1.4013e-045
    32 Does float adhere to IEC 559 standard?  1
    33 Is float bounded? 1
    34 Is float modulo?  0
    35 Is int modulo?    0
    36 Is trapping implemented for float?    1
    37 Is tinyness detected before rounding? 1
    38 What is the rounding style for float? 1
    39 What is the rounding style for int? 0
    40 How does a float represent a signaling NaN? -1.#INF
    41 Is int specialized? 1 
      

  4.   

    _fpclass
    Returns status word containing information on floating-point class.int _fpclass( double x );_FPCLASS_NINF Negative infinity ( –INF) 
    _FPCLASS_PINF Positive infinity (+INF) 或者 _finite
    Determines whether given double-precision floating point value is finite.int _finite( double x );_isnan
    Checks given double-precision floating-point value for not a number (NaN).int _isnan( double x );