Как рассчитать количество значащих десятичных цифр двойного числа С++?

При работе со значениями с плавающей запятой в Java вызов метода toString ()дает напечатанное значение с правильным количеством значащих цифр с плавающей запятой. Однако в C++ печать числа с плавающей запятой через stringstream будет округлять значение после 5 или менее цифр. Есть ли способ «красиво напечатать» число с плавающей запятой в C++ для (предполагаемого )правильного количества значащих цифр?

РЕДАКТИРОВАТЬ :Я думаю, что меня неправильно поняли. Я хочу, чтобы выходные данные имели динамическую длину, а не фиксированную точность. Я знаком с setprecision. Если вы посмотрите на исходный код java для Double, он каким-то образом вычисляет количество значащих цифр, и мне бы очень хотелось понять, как это работает и/или насколько возможно легко воспроизвести это на C++.

/*
 * FIRST IMPORTANT CONSTRUCTOR: DOUBLE
 */
public FloatingDecimal( double d )
{
    long    dBits = Double.doubleToLongBits( d );
    long    fractBits;
    int     binExp;
    int     nSignificantBits;

    // discover and delete sign
    if ( (dBits&signMask) != 0 ){
        isNegative = true;
        dBits ^= signMask;
    } else {
        isNegative = false;
    }
    // Begin to unpack
    // Discover obvious special cases of NaN and Infinity.
    binExp = (int)( (dBits&expMask) >> expShift );
    fractBits = dBits&fractMask;
    if ( binExp == (int)(expMask>>expShift) ) {
        isExceptional = true;
        if ( fractBits == 0L ){
            digits =  infinity;
        } else {
            digits = notANumber;
            isNegative = false; // NaN has no sign!
        }
        nDigits = digits.length;
        return;
    }
    isExceptional = false;
    // Finish unpacking
    // Normalize denormalized numbers.
    // Insert assumed high-order bit for normalized numbers.
    // Subtract exponent bias.
    if ( binExp == 0 ){
        if ( fractBits == 0L ){
            // not a denorm, just a 0!
            decExponent = 0;
            digits = zero;
            nDigits = 1;
            return;
        }
        while ( (fractBits&fractHOB) == 0L ){
            fractBits <<= 1;
            binExp -= 1;
        }
        nSignificantBits = expShift + binExp +1; // recall binExp is  - shift count.
        binExp += 1;
    } else {
        fractBits |= fractHOB;
        nSignificantBits = expShift+1;
    }
    binExp -= expBias;
    // call the routine that actually does all the hard work.
    dtoa( binExp, fractBits, nSignificantBits );
}

После этой функции она вызывает dtoa( binExp, fractBits, nSignificantBits );, которая обрабатывает кучу случаев -это из OpenJDK6

Для большей наглядности пример :Ява:

double test1 = 1.2593;
double test2 = 0.004963;
double test3 = 1.55558742563;

System.out.println(test1);
System.out.println(test2);
System.out.println(test3);

Выход:

1.2593
0.004963
1.55558742563

С++:

std::cout << test1 << "\n";
std::cout << test2 << "\n";
std::cout << test3 << "\n";

Выход:

1.2593
0.004963
1.55559