Converting strings to numbers - a question of speed

[zexpe]

I have an extremely cpu/data intensive piece of code that makes heavy
use of the following function:

void convertToDouble (const std::string& in, double& out)
{
out = atof(in.c_str() );
}

I would really like to get away from using any old C-style functions.
So, I modified the above function to make it follow the C++ convention:

void convertToDouble (const std::string& in, double& out)
{
std::stringstre am ss(in);
ss >> out;
}

However, my test code that previously took 30s to run, now takes 45s
(linux gcc 4.0.2 with -03 option). That's a heavy price to pay for
adopting the C++ convention. So, my question is... Is there an
*efficient* way to convert a string to a number (e.g. double) without
requiring the use of old C libraries?

[John Harrison]

zexpe wrote:

I have an extremely cpu/data intensive piece of code that makes heavy
use of the following function:

void convertToDouble (const std::string& in, double& out)
{
out = atof(in.c_str() );
}

I would really like to get away from using any old C-style functions.
So, I modified the above function to make it follow the C++ convention:

void convertToDouble (const std::string& in, double& out)
{
std::stringstre am ss(in);
ss >> out;
}

However, my test code that previously took 30s to run, now takes 45s
(linux gcc 4.0.2 with -03 option). That's a heavy price to pay for
adopting the C++ convention. So, my question is... Is there an
*efficient* way to convert a string to a number (e.g. double) without
requiring the use of old C libraries?

C is legal C++ (mostly). If the C version works better, why not use it?
C libraries aren't old, they're part of modern C++.

john

[Puppet_Sock]

zexpe wrote:

I have an extremely cpu/data intensive piece of code that makes heavy
use of the following function:

void convertToDouble (const std::string& in, double& out)
{
out = atof(in.c_str() );
}

I would really like to get away from using any old C-style functions.
So, I modified the above function to make it follow the C++ convention:

void convertToDouble (const std::string& in, double& out)
{
std::stringstre am ss(in);
ss >> out;
}

However, my test code that previously took 30s to run, now takes 45s
(linux gcc 4.0.2 with -03 option). That's a heavy price to pay for
adopting the C++ convention. So, my question is... Is there an
*efficient* way to convert a string to a number (e.g. double) without
requiring the use of old C libraries?

Hey, you could roll your own. <evil grin>

But seriously, what was the objection to using atof()? It's part of the
language for a reason. stringstream does plenty of stuff other than
just what atof does, so you get to pay for the overhead.

Also, you might be able to speed up some stuff about your stringstream
use, depending on exactly what your compiler is doing. For example,
what about making your variable ss static? You might check a few
examples of ways of doing that. Maybe the ctor call for strinstream is
where a lot of the extra time is going. But measure it before you
decide.
You also need to be more aware of initializing it as required on each
call instead of depending on the ctor to prepare it for you.
Socks

[deane_gavin]

John Harrison wrote:

zexpe wrote:

<snip code comparing atof and stringstream>

However, my test code that previously took 30s to run, now takes 45s
(linux gcc 4.0.2 with -03 option). That's a heavy price to pay for
adopting the C++ convention. So, my question is... Is there an
*efficient* way to convert a string to a number (e.g. double) without
requiring the use of old C libraries?

C is legal C++ (mostly). If the C version works better, why not use it?
C libraries aren't old, they're part of modern C++.

I may be wrong, but doesn't atof suffer from the same problem as atoi -
namely that it's impossible to distinguish correctly converting zero
from an error case. I believe strtod would be a better C library
solution.

Gavin Deane

[wittempj]

A more efficient approach using the same approach you have can be found
here:
http://www.parashift.com/c++-faq-lit....html#faq-39.2

[Greg]

Puppet_Sock wrote:

zexpe wrote:

I have an extremely cpu/data intensive piece of code that makes heavy
use of the following function:

void convertToDouble (const std::string& in, double& out)
{
out = atof(in.c_str() );
}

I would really like to get away from using any old C-style functions.
So, I modified the above function to make it follow the C++ convention:

void convertToDouble (const std::string& in, double& out)
{
std::stringstre am ss(in);
ss >> out;
}

However, my test code that previously took 30s to run, now takes 45s
(linux gcc 4.0.2 with -03 option). That's a heavy price to pay for
adopting the C++ convention. So, my question is... Is there an
*efficient* way to convert a string to a number (e.g. double) without
requiring the use of old C libraries?

Hey, you could roll your own. <evil grin>

But seriously, what was the objection to using atof()? It's part of the
language for a reason. stringstream does plenty of stuff other than
just what atof does, so you get to pay for the overhead.

atof() has been "deprecated " which means that it is on the way out of
the standard and should not be used in new code. It is also neither
thread-safe nor async canceable on most systems.

strtod() is the recommended replacement. Instead of calling atof like
this

#include <cstdlib>
char * nptr; // pointer to string of the number
...

double num = std::atof(nptr) ;

just replace it with a call to strtod():

double num = std::strtod(npt r, NULL);

Greg

[zexpe]

wi******@hotmai l.com wrote:

A more efficient approach using the same approach you have can be found
here:
http://www.parashift.com/c++-faq-lit....html#faq-39.2

Is that not the same solution?

How does it differ/improve the efficiency of the conversation?

[zexpe]

Puppet_Sock wrote:

Also, you might be able to speed up some stuff about your stringstream
use, depending on exactly what your compiler is doing. For example,
what about making your variable ss static? You might check a few
examples of ways of doing that. Maybe the ctor call for strinstream is
where a lot of the extra time is going. But measure it before you
decide.
You also need to be more aware of initializing it as required on each
call instead of depending on the ctor to prepare it for you.

Yep. If ss were static, you'd need to clear the stream each time. Can't
see it helping.

Thanks,
Ross

[zexpe]

Greg wrote:

just replace it with a call to strtod():

double num = std::strtod(npt r, NULL);

Thanks for the tip. I'll give it a go.

My main objection to the C-way, is having to use the old <cstdlib>
library, when I'm beginning to view C++ as a complete replacement for
C. I'd rather work with C++ objects, e.g. strings, and never have to
worry about pointers, char strings etc. forever more! However, I'm
beginning to see that C++ alternatives are not always as fast as the
original C versions!

Ross

[wittempj]

Well - it uses std::istringstr eam (specialised for reading) and the
function is inline, although I didn't do myself a measurement these two
differences are supposed to increase performance. But the stringstream
approach will give an overhead comparted to using a function like
mentioned on the other posts