Algo de conversion d'un double vers un char*

Hello,

Pour des raisons de performance, je suis en train de coder une
alternative =E0 sprintf.
Les r=E9sultats sont plut=F4t bons (x6) par contre je rencontre des
probl=E8mes num=E9riques sur certaines valeurs.

Par exemple :

d =3D 0.00000000001;
double_to_ascii( d, s ); // >> 0.00000000000999

Je suis preneur de toute suggestion on autre piste algorithmique.
Merci !

G



Voici le code


#include <stdio.h>
#include <ctime>
#include <string>
#include <sstream>
#include <iostream>

class timer
{
private:
clock_t t0;
std::string s;

public:
timer( std::string msg )
{
s =3D msg;
t0 =3D clock();
}
~timer()
{
double x =3D ( clock() - t0 ) / ( double ) CLOCKS_PER_SEC;
std::stringstream ss;
ss << x;
std::cout << s << " : " << ss.str() << std::endl;
}
};


void double_to_ascii( double d, char* s )
{
int p =3D 15;

// negative case
if ( d < 0 )
{
*s++ =3D '-';
d =3D -d;
}

// exponential format is dealt with sprintf
const double thres_max =3D (double)(0x7FFFFFFF);
if( d > thres_max )
{
sprintf( s, "%.15G", d );
return;
}

// int / dec parts
int int_d =3D ( int )d;
double dec_d =3D d - int_d;

// int part
char* s_begin =3D s;
do
{
*s++ =3D ( char )( 48 + ( int_d % 10) );
--p;
}
while( int_d /=3D 10 );

// reverse
char* s_end =3D s - 1;
while( s_end > s_begin )
{
char c =3D *s_end;
*s_end-- =3D *s_begin;
*s_begin++ =3D c;
}

// ignore null decimal part
if( dec_d !=3D 0 )
{
// dec separator
*s++ =3D '.';

// dec part
for( int i =3D 0;
i < p;
i++ )
{
double x =3D dec_d * 10;
int_d =3D (int) x;
*s++ =3D ( char )( 48 + int_d );
dec_d =3D x - int_d;
}
}
*s =3D '\0';

}


int main()
{

//------------------ VALUES

double d;
char s[24];

d =3D 0.00000000001;
double_to_ascii( d, s ); /// 0.00000000000999


//------------------ PERFS

const int n =3D 10000000;

{
timer T("double_to_ascii");
for( int i =3D 0; i < n; i++ )
{
double_to_ascii( d, s );
}
}

{
timer T("sprintf");
for( int i =3D 0; i < n; i++ )
{
sprintf( s, "%.15G", d );
}
}

system( "pause" );
return 0;
}