What is difference between std::stof and atof when each one should be used?

Question

I have read some documents about each, for example

http://www.cplusplus.com/reference/string/stof/

http://www.cplusplus.com/reference/cstdlib/atof/

I understand that atof is part of <cstdlib> and has const char* as input parameter, and std::stof is part of <string> and has different input format.

But it's not clear,

• can they be used interchangeably:
• do they convert to same float value with same input?
• what scenario is best to use for each of these?

Answer 1

I assume you meant to compare std::atof with std::stod (both return double).

Just comparing the two linked reference pages yields the following differences :

• std::atof takes a char*, while std::stod takes either a std::string or a std::wstring (ie. it has support for wide strings)
• std::stod will also return the index of the first unconverted character if the pos parameter is not NULL (useful for further parsing of the string)
• if the converted value falls outside of the range of a double, std::atof will return an undefined value, while std::stod will throw a std::out_of_range exception (definitely better than an undefined value)
• if no conversion can be performed, std::atof will return 0.0, while std::stod will throw a std::invalid_argument exception (easier to distinguish with an actual converted 0.0)

These are all positive points for std::stod, making it the more advanced alternative of the 2.

Answer 2

Everything Sander said is correct. However, you specifically asked:

Can they be used interchangeably?

The answer is no, at least not in the general case. If you're using atof, chances are good that you have legacy C code. In that case, you must be careful about introducing code that can throw exceptions, especially in "routine" situations such as when a user gives bad input.

Do they convert to same float value with same input?

No. They both convert to a double value, not a float. Conversion to the same value isn't specifically guaranteed by the standard (to my knowledge), and it is possible that there is round-off somewhere that is slightly different. However, given valid input, I would be pretty surprised if there were a difference between the return values from the two in the same compiler.

What scenario is best to use for each of these?

If:

• You have a conforming C++ 11 or later compiler, and
• Your code can tolerate exceptions (or you're willing to catch them around every call), and
• You already have a std::string or the performance hit of a conversion is unimportant.
• Or, if you are a C++ beginner and don't know the answers to these questions.

Then I would suggest using std::stod. Otherwise, you could consider using atof.