bicycle:  0.135
crt::     0.682   (в 5 раз медленнее)
boost:    6.289   (в 46.5 раз медленнее велосипеда и в 10 раз медленнее crt)

#pragma comment(lib, "Winmm.lib")

int main(int argc, char* argv[])
{
    DWORD t;
    double d, tmp;
    const char *str = "3.1415", *end = str + strlen(str);

    for (int k = 0; k < 3; k++)
    {
    // boost
        d = 0; t = timeGetTime();
        for (int i = 0; i < 1000000; i++)
        {
            d += lexical_cast<double>(str);
        }
        t = timeGetTime() - t;
        printf("boost: %g: %g\n", d, t*1e-3);

    // crt
        d = 0; t = timeGetTime();
        for (int i = 0; i < 1000000; i++)
        {
            char *p;
            d += strtod(str, &p);
        }
        t = timeGetTime() - t;
        printf("crt: %g: %g\n", d, t*1e-3);

    // bicycle
        d = 0; t = timeGetTime();
        for (int i = 0; i < 1000000; i++)
        {
            const char *cp;
            num_parse(&tmp, &cp, str, end);
            d += tmp;
        }
        t = timeGetTime() - t;
        printf("bicycle: %g: %g\n", d, t*1e-3);
    }
    return 0;
}

Но не смотря на свою красоту, универсальность и соответствие общепринятым стандартам преобразования, у boost::lexical_cast есть и следущие недостатки:

1. Низкая скорость работы. По тестам, проведенным Гербом Саттером, результаты которых он описал в своих “Новых сложных задачах на С++”, boost::lexical_cast работает на порядок медленнее, чем тот же sprintf.

Два из трех указанных выше недостатков достаточно легко обходятся. Поскольку boost::lexical_cast — это шаблон, то достаточно несложно написать необходимую специализацию, выполняющую преобразование настолько быстро, насколько это необходимо разработчику, а также учитывающую особенности типа wchar_t в VC++.

template<class VAL, class Ch> inline
VAL from_string(const std::basic_string<Ch> &str)
{
    static std::locale loc("Russian_Russia");
    static std::ios_base::iostate st = 0;
    static std::basic_istringstream<Ch> iss;
    VAL ret_val;
    std::use_facet<num_get<Ch, typename std::basic_string<Ch>::const_iterator> >(loc).get(str.begin(), str.end(), iss, st, ret_val);
    return ret_val;
}

double d = from_string<double>(str);

K>bicycle:  0.135
K>crt::     0.682   (в 5 раз медленнее)
K>boost:    6.289   (в 46.5 раз медленнее велосипеда и в 10 раз медленнее crt)
K>

StrToDouble: Done
  CRT     : ( 1.734827)  4'648'555'990
  CrayLib : ( 0.082319)    220'579'670
  Difference : 21.074272

template <class Char> int // разбор сишной строки
    parse(double &result, const Char *str);

template <class Char> int // разбор фрагмента строки
    parse(double &result, const Char *&pos, const Char *end);

template <class Char> int // аналогично для интов
    parse(int &result, const Char *str);

template <class Char> int
    parse(int &result, const Char *&pos, const Char *end);

template <class Result, class Char> Result
    lexical_cast(const Char *str)
{
    Result r;
    if (int errcode = parse(r, str))
        throw CastError(errcode);
    return r;
}

bool parse(int &r, const char *s)
{
    char *p;
    r = strtol(s, &p, 10);
    if (s == p || errno)
        return false;
    return *p == 0 || isspace((int)*p);
}

bool parse(double &r, const char *s)
{
    char *p;
    r = strtod(s, &p);
    if (s == p || errno)
        return false;
    return *p == 0 || isspace((int)*p);
}

// .....

template <class Result> Result
    lexical_cast(const char *str)
{
    if (!str)
        throw std::exception();

    Result r;
    if (!parse(r, str))
        throw std::exception();
    return r;
}

K>bool parse(int &r, const char *s)
K>{
K>    char *p;
K>    r = strtol(s, &p, 10);
K>    if (s == p || errno)
K>        return false;
K>    return *p == 0 || isspace((int)*p);
K>}

K>bool parse(double &r, const char *s)
K>{
K>    char *p;
K>    r = strtod(s, &p);
K>    if (s == p || errno)
K>        return false;
K>    return *p == 0 || isspace((int)*p);
K>}

K>// .....

K>template <class Result> Result
K>    lexical_cast(const char *str)
K>{
K>    if (!str)
K>        throw std::exception();

K>    Result r;
K>    if (!parse(r, str))
K>        throw std::exception();
K>    return r;
K>}
K>

//The following example uses numeric data in a string expression: void log_message(const std::string &);

void log_errno(int yoko)
{
    log_message("Error " + boost::lexical_cast<std::string>(yoko) + ": " + strerror(yoko));
}

K>bicycle:  0.135
K>crt::     0.682   (в 5 раз медленнее)
K>boost:    6.289   (в 46.5 раз медленнее велосипеда и в 10 раз медленнее crt)
K>

boost: 3.1415e+006: 3.027
crt: 3.1415e+006: 0.639
boost: 3.1415e+006: 3.042
crt: 3.1415e+006: 0.64
boost: 3.1415e+006: 3.042
crt: 3.1415e+006: 0.624

Level,Function Name,Inclusive Samples,Exclusive Samples,Inclusive Samples %,Exclusive Samples %,Module Name,
0,"lexical_cast_perf.exe","2,183",0,100.00,0.00,"",
0,"_mainCRTStartup","2,183",0,100.00,0.00,"lexical_cast_perf.exe",
4,"[4 rows folded ending in "__fltin2"]",323,12,14.80,0.55,"lexical_cast_perf.exe",
5,"___strgtold12_l",266,188,12.19,8.61,"lexical_cast_perf.exe",
6,"___mtold12",78,78,3.57,3.57,"lexical_cast_perf.exe",
1,"Unknown Frame(s)","1,811",0,82.96,0.00,"UNKNOWN",
2,"_main","1,677",51,76.82,2.34,"lexical_cast_perf.exe",
3,"__Mtxunlock",78,5,3.57,0.23,"lexical_cast_perf.exe",
4,"[ntdll.dll]",67,67,3.07,3.07,"ntdll.dll",
4,"[2 rows folded ending in "_malloc"]",89,12,4.08,0.55,"lexical_cast_perf.exe",
5,"[ntdll.dll]",77,23,3.53,1.05,"ntdll.dll",
4,"[2 rows folded ending in "__Mtxlock"]",93,6,4.26,0.27,"lexical_cast_perf.exe",
5,"[ntdll.dll]",87,87,3.99,3.99,"ntdll.dll",
3,"std::ios_base::_Ios_base_dtor(class std::ios_base *)",106,4,4.86,0.18,"lexical_cast_perf.exe",
4,"std::locale::`scalar deleting destructor'(unsigned int)",96,10,4.40,0.46,"lexical_cast_perf.exe",
4,"[2 rows folded ending in "__Mtxdst"]",79,2,3.62,0.09,"lexical_cast_perf.exe",
5,"[ntdll.dll]",77,15,3.53,0.69,"ntdll.dll",
3,"std::_Mutex::_Mutex(void)",145,7,6.64,0.32,"lexical_cast_perf.exe",
5,"[2 rows folded ending in "[ntdll.dll]"]",74,4,3.39,0.18,"ntdll.dll",
6,"[ntdll.dll]",70,9,3.21,0.41,"ntdll.dll",
3,"std::basic_istream<char,struct std::char_traits<char> >::operator>>(double &)",801,36,36.69,1.65,"lexical_cast_perf.exe",
4,"std::num_get<char,class std::istreambuf_iterator<char,struct std::char_traits<char> > >::do_get(class std::istreambuf_iterator<char,struct std::char_traits<char> >,class std::istreambuf_iterator<char,struct std::char_traits<char> >,class std::ios_base &,int &,double &)const ",650,11,29.78,0.50,"lexical_cast_perf.exe",
5,"std::num_get<char,class std::istreambuf_iterator<char,struct std::char_traits<char> > >::_Getffld(char *,class std::istreambuf_iterator<char,struct std::char_traits<char> > &,class std::istreambuf_iterator<char,struct std::char_traits<char> > &,class std::locale const &)const ",168,98,7.70,4.49,"lexical_cast_perf.exe",
6,"[2 rows folded ending in "_strtod"]",335,4,15.35,0.18,"lexical_cast_perf.exe",
8,"[2 rows folded ending in "__fltin2"]",294,8,13.47,0.37,"lexical_cast_perf.exe",
9,"___strgtold12_l",250,164,11.45,7.51,"lexical_cast_perf.exe",
10,"___mtold12",84,83,3.85,3.80,"lexical_cast_perf.exe",

double my_bicycle(const char *)
{
    return 3.1415;
}

anc>double my_bicycle(const char *)
anc>{
anc>    return 3.1415;
anc>}

anc>

int num_parse
(
  double    *num,
  const char  **stop,
  const char  *p,
  const char  *end
)
{
  i64    ct;
  int    neg;
  double val;
  int    ep;
  int    ep_neg;
  uchar  c;
  int    digs;
  double tmp;

  static CharType ctype;

  for ( ;; ) {
    if ( p < end )
      ct = ctype.type( c = *p );
    else
      goto err_eof;

    if ( ct & char_t::space )
      ++p;
    else
      break;
  }

  if ( ct & char_t::sign ) {
    neg = ( '-' == c );
    if ( ++p == end )
      goto err_eof;
    ct = ctype.type( c = *p );
  }
  else
    neg = false;

  // first char
  if ( ct & char_t::digit )
    { val = c - '0'; ++p; }
  else if ( '.' == c )
    { val = 0; ++p; digs = 0; goto dot_ok; }

  for (;;) {
    if ( p < end )
      ct = ctype.type( c = *p );
    else
      goto ip_eof;

    if ( ct & char_t::digit )
      val = val * 10 + (c-'0');
    else
      goto ip_ok;
    ++p;
  }

ip_ok:

  digs = 0;

  if ( '.' != c )
    goto fp_ok;
  else
    ++p;

dot_ok:

  for (;;) {
    if ( p < end )
      ct = ctype.type( c = *p );
    else
      goto fp_eof;

    if ( ct & char_t::digit ) {
      val = val * 10 + (c-'0');
      --digs;
    }
    else
      goto fp_ok;

    ++p;
  }

fp_ok:

  if ( 'E' == c || 'D' == c || 'e' == c || 'd' == c )
    ++p;
  else
    goto fp_eof;

  if ( p == end )
    goto err_eof;

  ct = ctype.type( c = *p );
  if ( ct & char_t::sign ) {
    ep_neg = ( '-' == c );
    if ( ++p == end )
      goto err_eof;
    else
      ct = ctype.type( c = *p );
  }
  else
    ep_neg = false;

// first char
  if ( ct & char_t::digit )
    { ep = c - '0'; ++p; }
  else
    goto err_syntax;
  
  for ( ;; ) {
    if ( p < end )
      ct = ctype.type( c = *p );
    else
      break;

    if ( ct & char_t::digit ) {
      ep = ep * 10 + (c-'0');
    }
    else
      break;
    
    ++p;
  }

  if ( ep_neg )
    digs -= ep;
  else
    digs += ep;

  *stop = p;
  tmp = pow( 10., digs );
  *num = neg ? -(tmp * val) : tmp * val;
  return num_parse_ok;

ip_eof:
  *stop = p;
  *num = neg ? 0.-val : val;
  return num_parse_ok;

fp_eof:
  *stop = p;
  tmp = pow( 10., digs );
  *num = neg ? -(tmp * val) : tmp * val;
  return num_parse_ok;

err_eof:
  *stop = p;
//  *num = 0;
  return num_parse_eof;

err_syntax:
  *stop = p;
//  *num = 0;
  return num_parse_syntax;

}

*end = str + strlen(str);

#include <iostream>
struct Lexical_cast
{  char *v;
   Lexical_cast(char *v):v(v){}
   operator int    () {return 1;}
   operator float  () {return 2;}
   operator double () {return 3;}
};
int main()
{
    int a=Lexical_cast("");
    float b=Lexical_cast("");
    std::cout << "Hello, world!" << a <<" "<< b<<" "<<(double)Lexical_cast("")<<std::endl;
    return 0;
}

P>#include <iostream>
P>struct Lexical_cast
P>{  char *v;
P>   Lexical_cast(char *v):v(v){}
P>   operator int    () {return 1;}
P>   operator float  () {return 2;}
P>   operator double () {return 3;}
P>};
P>

std::string s = "number = " + Lexical_cast(3.14) + s2 + Lexical_cast(x);

(gdb) break malloc
Breakpoint 2 at 0xb7cdcf36
(gdb) continue
Continuing.

Breakpoint 2, 0xb7cdcf36 in malloc () from /lib/tls/i686/cmov/libc.so.6
(gdb) bt
#0 0xb7cdcf36 in malloc () from /lib/tls/i686/cmov/libc.so.6
#1 0xb7ea56a7 in operator new () from /usr/lib/libstdc++.so.6
#2 0xb7e7f8c1 in std::string::_Rep::_S_create () from /usr/lib/libstdc++.so.6
#3 0xb7e805a8 in std::string::_Rep::_M_clone () from /usr/lib/libstdc++.so.6
#4 0xb7e811b8 in std::string::reserve () from /usr/lib/libstdc++.so.6
#5 0xb7e7a5b3 in std::basic_stringbuf<char, std::char_traits<char>, std::allocator<char> >::overflow () from /usr/lib/libstdc++.so.6
#6 0xb7e7eecb in std::basic_streambuf<char, std::char_traits<char> >::xsputn () from /usr/lib/libstdc++.so.6
#7 0xb7e755af in std::__ostream_insert<char, std::char_traits<char> > () from /usr/lib/libstdc++.so.6
#8 0xb7e757ac in std::operator<< <std::char_traits<char> > () from /usr/lib/libstdc++.so.6
#9 0x08048ba7 in boost::detail::lexical_stream<double, char const*>::operator<< (this=0xbff63d98, input=@0xbff63e6c)
at /usr/include/boost/lexical_cast.hpp:151
#10 0x08048cf5 in boost::lexical_cast<double, char [4]> (arg=@0x8048ef7) at /usr/include/boost/lexical_cast.hpp:222
#11 0x0804899c in main () at lexical_cast.cpp:10
(gdb) continue
Continuing.

Breakpoint 2, 0xb7cdcf36 in malloc () from /lib/tls/i686/cmov/libc.so.6
(gdb) bt
#0 0xb7cdcf36 in malloc () from /lib/tls/i686/cmov/libc.so.6
#1 0xb7cdcf65 in malloc () from /lib/tls/i686/cmov/libc.so.6
#2 0xb7ea56a7 in operator new () from /usr/lib/libstdc++.so.6
#3 0xb7e7f8c1 in std::string::_Rep::_S_create () from /usr/lib/libstdc++.so.6
#4 0xb7e805a8 in std::string::_Rep::_M_clone () from /usr/lib/libstdc++.so.6
#5 0xb7e811b8 in std::string::reserve () from /usr/lib/libstdc++.so.6
#6 0xb7e7a5b3 in std::basic_stringbuf<char, std::char_traits<char>, std::allocator<char> >::overflow () from /usr/lib/libstdc++.so.6
#7 0xb7e7eecb in std::basic_streambuf<char, std::char_traits<char> >::xsputn () from /usr/lib/libstdc++.so.6
#8 0xb7e755af in std::__ostream_insert<char, std::char_traits<char> > () from /usr/lib/libstdc++.so.6
#9 0xb7e757ac in std::operator<< <std::char_traits<char> > () from /usr/lib/libstdc++.so.6
#10 0x08048ba7 in boost::detail::lexical_stream<double, char const*>::operator<< (this=0xbff63d98, input=@0xbff63e6c)
at /usr/include/boost/lexical_cast.hpp:151
#11 0x08048cf5 in boost::lexical_cast<double, char [4]> (arg=@0x8048ef7) at /usr/include/boost/lexical_cast.hpp:222
#12 0x0804899c in main () at lexical_cast.cpp:10
(gdb) continue
Continuing.

Breakpoint 2, 0xb7cdcf36 in malloc () from /lib/tls/i686/cmov/libc.so.6
(gdb) bt
#0 0xb7cdcf36 in malloc () from /lib/tls/i686/cmov/libc.so.6
#1 0xb7ea56a7 in operator new () from /usr/lib/libstdc++.so.6
#2 0xb7e7f8c1 in std::string::_Rep::_S_create () from /usr/lib/libstdc++.so.6
#3 0xb7e805a8 in std::string::_Rep::_M_clone () from /usr/lib/libstdc++.so.6
#4 0xb7e811b8 in std::string::reserve () from /usr/lib/libstdc++.so.6
#5 0xb7e6de2c in std::num_get<char, std::istreambuf_iterator<char, std::char_traits<char> > >::do_get () from /usr/lib/libstdc++.so.6
#6 0xb7e53927 in std::istream::_M_extract<double> () from /usr/lib/libstdc++.so.6
#7 0xb7e539c4 in std::istream::operator>> () from /usr/lib/libstdc++.so.6
#8 0x08048bdd in boost::detail::lexical_stream<double, char const*>::operator>><double> (this=0xbff63d98, output=@0xbff63e60)
at /usr/include/boost/lexical_cast.hpp:166
#9 0x08048d11 in boost::lexical_cast<double, char [4]> (arg=@0x8048ef7) at /usr/include/boost/lexical_cast.hpp:222
#10 0x0804899c in main () at lexical_cast.cpp:10
(gdb) continue
Continuing.

Program exited normally.

void foo()
{
    char buf[64];
    float v1 = pow (10.0,1000000);
    float v2;

    v1 += -v1;    // Create qNaN

    crprintf (L"%f\n",v1);
    printf ("%f\n",v1);

    sprintf (buf,"%f",v1);
    sscanf (buf,"%f",&v2);

    printf ("%s -> %f\n",buf,v2);
}

qNaN
-1.#IND00
-1.#IND00 -> -1.000000

struct person
{
  int id;
  std::string first_name;
  std::string last_name;
  int age;
  address_info address;
  document_info doc;
};

    stringstream ss;
    string a, b, c = "vasya pupkin";

    ss << c;
    ss >> a >> b;

for( int i = 0; i < count; i++ ) {
    doIt( i );
}

int i = 0;
for(;;) {
    if( i < count ) {
        doIt( i++ );
    } else {
        break;
    }
}

"boost::lexical_cast" даже по названию может прити в голову что это не инструмент конвертирования строки в дабл а некий универсальный преобразователь типов.