[C++] Problema nella visualizzazione delle cifre significative

[>Alexan<]

Ciao a tutti! sono alle prime armi nella programmazione in C++...
per esercizio ho scritto un programmino che calcola il valore di pi greco con la precisione voluta. il problema è che vorrei visualizzare più di 6 cifre significative, ma pur impostando le variabili in double il numero di cifre mostrate non cambia!
il codice è il seguente:

#include <math.h>
#include <iostream>
using namespace std;
main()
{
  int i=1;double pi_ben_ecc=4,pi_ben_dif=2*sqrt(2),pi_mal_ecc=4,pi_mal_dif=2*sqrt(2),epsilon;
  cout << "\n\n  inserire l'errore desiderato\n\n     epsilon = ";cin >> epsilon;
  while (pi_ben_ecc-pi_ben_dif>epsilon)
    {
      pi_ben_dif=(2*pi_ben_dif)/sqrt(2+sqrt(4-pow(pi_ben_dif/(pow(2,i)),2)));
      pi_ben_ecc=(2*pi_ben_dif)/(sqrt(4-pow((pi_ben_dif/(pow(2,i))),2)));
      pi_mal_dif=pow(2,(i+1))*sqrt(2-sqrt(4-(pi_mal_dif)/(pow(2,i))));
      pi_mal_ecc=(2*pi_mal_dif)/(sqrt(4-pow((pi_mal_dif/(pow(2,i))),2)));
      i++;
    }
  cout << "\n\n\n  le approssimazioni per eccesso e per difetto di pi greco\n  determinate attraverso l'algoritmo di archimede ben condizionato\n  dopo " << i << " iterazioni sono:\n\n     per eccesso: " << pi_ben_ecc << "\n     per difetto: " << pi_ben_dif;
  cout << "\n\n\n  le approssimazioni per eccesso e per difetto di pi greco\n  determinate attraverso l'algoritmo di archimede mal condizionato\n  dopo " << i << " iterazioni sono:\n\n     per eccesso: " << pi_mal_ecc << "\n     per difetto: " << pi_mal_dif << "\n\n\n";
  return 0;
}

se vi aiuta a darmi una mano programmo su linux e compilo con GPP. grazie a tutti

[Gimli[2BV!2B]]

Si può utilizzare limits per conoscere il numero corretto di cifre significative, quindi precision per comunicalo a cout.
Trattandosi di un programma che mastica numeri ho passato anche tutto a long double per mostrare il numero di cifre dei tipi di dato floating comuni.
(Linux, g++)

#include <math.h>
#include <iostream>
//#include <iomanip> //necessario solo per std::setprecision ed altri manipolatori
#include <limits>

using namespace std;

typedef std::numeric_limits< float > flt;
typedef std::numeric_limits< double > dbl;
typedef std::numeric_limits< long double > ldbl;

int main()
{
  int i = 1;
  long double pi_ben_ecc, pi_mal_ecc,
         pi_ben_dif, pi_mal_dif,
         epsilon = 0.1;

  pi_ben_ecc = pi_mal_ecc = 4;
  pi_ben_dif = pi_mal_dif = 2 * sqrtl(2);
 
  cout << "\n\n  inserire l'errore desiderato\n\n     epsilon = ";
  cin >> epsilon;

  while ( pi_ben_ecc - pi_ben_dif > epsilon )
    {
      pi_ben_dif = (2 * pi_ben_dif) / sqrtl(2 + sqrtl(4 - powl(pi_ben_dif / powl(2, i), 2)));
      pi_ben_ecc = (2 * pi_ben_dif) /           sqrtl(4 - powl(pi_ben_dif / powl(2, i), 2));

      pi_mal_dif = powl(2, (i+1)) * sqrtl(2 - sqrtl(4 - pi_mal_dif / powl(2,i)));
      pi_mal_ecc = (2 * pi_mal_dif) /           sqrtl(4 - powl(pi_mal_dif / powl(2, i), 2));
      ++ i;
    }

  cout << "\n\n\n  le approssimazioni per eccesso e per difetto di pi greco"
          "\n  determinate attraverso l'algoritmo di archimede ben condizionato"
          "\n  dopo " << i << " iterazioni sono:";

  cout.precision( flt::digits10 );
  cout << "\n\n(flt) per eccesso: " << pi_ben_ecc <<
          "\n(flt) per difetto: " << pi_ben_dif;

  cout.precision( dbl::digits10 );
  cout << "\n\n(dbl) per eccesso: " << pi_ben_ecc <<
          "\n(dbl) per difetto: " << pi_ben_dif;

  cout.precision( ldbl::digits10 );
  cout << "\n\n(ldbl)per eccesso: " << pi_ben_ecc <<
          "\n(ldbl)per difetto: " << pi_ben_dif;

  cout << "\n\n\n  le approssimazioni per eccesso e per difetto di pi greco"
          "\n  determinate attraverso l'algoritmo di archimede mal condizionato"
          "\n  dopo " << i << " iterazioni sono:"
          "\n\n     per eccesso: " << pi_mal_ecc <<
          "\n     per difetto: " << pi_mal_dif;

  cout << "\n\n\n";
  return 0;
}

Esempio esecuzione (notare troncamento automatico zeri nel secondo dbl):

  inserire l'errore desiderato

     epsilon = 0.00000000001



  le approssimazioni per eccesso e per difetto di pi greco
  determinate attraverso l'algoritmo di archimede ben condizionato
  dopo 21 iterazioni sono:

(flt) per eccesso: 3.14159
(flt) per difetto: 3.14159

(dbl) per eccesso: 3.14159265359302
(dbl) per difetto: 3.1415926535895

(ldbl)per eccesso: 3.14159265359302449
(ldbl)per difetto: 3.14159265358949949


  le approssimazioni per eccesso e per difetto di pi greco
[...]

Una paginetta con un po' di nozioni sull'argomento formattazione: Output Formatting.