...one of the most highly
regarded and expertly designed C++ library projects in the
world.
— Herb Sutter and Andrei
Alexandrescu, C++
Coding Standards
The following example treats command line arguments as a sequence of numeric data
#include <boost/lexical_cast.hpp> #include <vector> int main(int /*argc*/, char * argv[]) { using boost::lexical_cast; using boost::bad_lexical_cast; std::vector<short> args; while (*++argv) { try { args.push_back(lexical_cast<short>(*argv)); } catch(const bad_lexical_cast &) { args.push_back(0); } } // ... }
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)); }
The following example converts some number and puts it to file:
void number_to_file(int number, FILE* file) { typedef boost::array<char, 50> buf_t; // You can use std::array if your compiler supports it buf_t buffer = boost::lexical_cast<buf_t>(number); // No dynamic memory allocation fputs(buffer.begin(), file); }
The following example takes part of the string and converts it to int
:
int convert_strings_part(const std::string& s, std::size_t pos, std::size_t n) { return boost::lexical_cast<int>(s.data() + pos, n); }
In this example we'll make a stringize
method that accepts a sequence, converts each element of the sequence into
string and appends that string to the result.
Example is based on the example from the Boost C++ Application Development Cookbook by Antony Polukhin, ISBN 9781849514880.
Step 1: Making a functor that converts any type to a string and remembers result:
#include <boost/lexical_cast.hpp> struct stringize_functor { private: std::string& result; public: explicit stringize_functor(std::string& res) : result(res) {} template <class T> void operator()(const T& v) const { result += boost::lexical_cast<std::string>(v); } };
Step 2: Applying stringize_functor
to each element in sequence:
#include <boost/fusion/include/for_each.hpp> template <class Sequence> std::string stringize(const Sequence& seq) { std::string result; boost::fusion::for_each(seq, stringize_functor(result)); return result; }
Step 3: Using the stringize
with different types:
#include <cassert> #include <boost/fusion/adapted/boost_tuple.hpp> #include <boost/fusion/adapted/std_pair.hpp> int main() { boost::tuple<char, int, char, int> decim('-', 10, 'e', 5); assert(stringize(decim) == "-10e5"); std::pair<short, std::string> value_and_type(270, "Kelvin"); assert(stringize(value_and_type) == "270Kelvin"); }
In this example we'll make a to_long_double
method that converts value of the Boost.Variant to long
double
.
#include <boost/lexical_cast.hpp> #include <boost/variant.hpp> #include <cassert> struct to_long_double_functor: boost::static_visitor<long double> { template <class T> long double operator()(const T& v) const { // Lexical cast has many optimizations including optimizations for situations that usually // occur in generic programming, like std::string to std::string or arithmetic type to arithmetic type conversion. return boost::lexical_cast<long double>(v); } }; // Throws `boost::bad_lexical_cast` if value of the variant is not convertible to `long double` template <class Variant> long double to_long_double(const Variant& v) { return boost::apply_visitor(to_long_double_functor(), v); } int main() { boost::variant<char, int, std::string> v1('0'), v2("10.0001"), v3(1); long double sum = to_long_double(v1) + to_long_double(v2) + to_long_double(v3); assert(sum > 11 && sum < 11.1); }