boost::lexical_cast can convert hex inside string to int? - c++

Question

I see in this topic C++ convert hex string to signed integer that boost::lexical_cast can convert hexadecimal inside string to another type (int, long...)
but when I tried this code:
std::string s = "0x3e8";
try {
auto i = boost::lexical_cast<int>(s);
std::cout << i << std::endl; // 1000
}
catch (boost::bad_lexical_cast& e) {
// bad input - handle exception
std::cout << "bad" << std::endl;
}
It ends with a bad lexical cast exception !
boost doesn't support this kind of cast from string hex to int ?

Answer 1

As per the answer from C++ convert hex string to signed integer:
It appears that since lexical_cast<> is defined to have stream conversion semantics. Sadly, streams don't understand the "0x" notation. So both the boost::lexical_cast and my hand rolled one don't deal well with hex strings.
Also, as per boost::lexical_cast<> documentation
The lexical_cast function template offers a convenient and consistent form for supporting common conversions to and from arbitrary types when they are represented as text. The simplification it offers is in expression-level convenience for such conversions. For more involved conversions, such as where precision or formatting need tighter control than is offered by the default behavior of lexical_cast, the conventional std::stringstream approach is recommended.
So for more involved conversion, std::stringstream is recommended.
If you have access to C++11 compiler, you can use std::stoi to convert any hexadecimal sting to an integer value.
stoi prototype is:
int stoi( const std::string& str, std::size_t* pos = nullptr, int base = 10 );
Your program can be converted to
int main() {
std::string s = "3e8";
auto i = std::stoi(s, nullptr, 16);
std::cout << i << '\n';
}
And the output will be
1000

Answer 2

What you want exists in Boost Convert:
Boost.Convert builds on the boost::lexical_cast experience and takes
those type conversion/transformation-related ideas further
to be applicable to a wider range of conversion-related deployment scenarios,
to provide a more flexible, configurable and extendible type-conversion framework,
to provide generic consistent behavior,
to unify and to uniformly deploy various conversion facilities through one consistent interface.
Simple Usage
You can e.g. use stream conversion:
boost::cnv::cstream converter;
You can configure it with the manipulators you want, e.g.:
converter(std::hex)(std::skipws); // IO manipulators
You could use directly:
boost::optional<int> i;
converter(s, i);
std::cout << i << std::endl; // 1000
But I'd suggest applying with pre-configured error-handling:
auto f = apply<int>(std::ref(converter))
.value_or(-1); // decorate error-handling
Now you can simply write:
for (auto s : cases)
std::cout << f(s) << std::endl;
Live Demo
Live On Coliru
#include <boost/convert.hpp>
#include <boost/convert/stream.hpp>
#include <iostream>
static const std::string cases[]{
"0x3e8", "3e8", "-7a", "-0x7a",
"0x-7a", // error
};
int main() {
boost::cnv::cstream converter;
converter(std::hex)(std::skipws); // IO manipulators
auto f = apply<int>(std::ref(converter)).value_or(-1); // decorate error-handling
for (auto s : cases)
std::cout << std::quoted(s) << " -> " << f(s) << std::endl;
auto g = apply<int>(std::ref(converter)); // throwing
for (auto s : cases)
try {
std::cout << std::quoted(s) << " -> " << g(s) << std::endl;
} catch (std::exception const& e) {
std::cout << e.what() << std::endl;
}
}
Prints
"0x3e8" -> 1000
"3e8" -> 1000
"-7a" -> -122
"-0x7a" -> -122
"0x-7a" -> -1
"0x3e8" -> 1000
"3e8" -> 1000
"-7a" -> -122
"-0x7a" -> -122
"0x-7a" -> Attempted to access the value of an uninitialized optional object.