Boost C++ Libraries Home Libraries People FAQ More

PrevUpHomeNext

Examples

Strings to numbers conversion
Numbers to strings conversion
Converting to string without dynamic memory allocation
Converting part of the string
Generic programming (Boost.Fusion)
Generic programming (Boost.Variant)

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, std::FILE* file)
{
    using buf_t = std::array<char, 50>;
    buf_t buffer = boost::lexical_cast<buf_t>(number); // No dynamic memory allocation
    std::fputs(buffer.data(), 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. Russian translation: ISBN: 9785970608685.

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 <boost/fusion/adapted/std_tuple.hpp>
#include <boost/fusion/adapted/std_pair.hpp>

int main() {
    std::tuple<char, int, char, int> decim('-', 10, 'e', 5);
    if (stringize(decim) != "-10e5") {
        return 1;
    }

    std::pair<int, std::string> value_and_type(270, "Kelvin");
    if (stringize(value_and_type) != "270Kelvin") {
        return 2;
    }

    return 0;
}

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>

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

    const long double sum = to_long_double(v1) + to_long_double(v2) + to_long_double(v3);
    if (11 < sum  && sum < 11.1) {
        return 0;  // OK, as expected
    };

    return 1;      // FAIL
}


PrevUpHomeNext