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;
}

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);

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;
}