Следующий пример рассматривает аргументы командной строки как последовательность числовых данных.

#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);
        }
    }
    // ...
}

Следующий пример использует числовые данные в выражении строки:

void log_message(const std::string &);
void log_errno(int yoko)
{
    log_message("Error " + boost::lexical_cast<std::string>(yoko) + ": " + strerror(yoko));
}

Следующий пример преобразует некоторое число и помещает его в файл:

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
    std::fputs(buffer.begin(), file);
}

Следующий пример берет часть строки и преобразует ее в<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);
}

В этом примере мы сделаем метод<stringize>, который принимает последовательность, преобразует каждый элемент последовательности в строку и добавляет эту строку к результату.

Пример основан на примереBoost C++ Application Development CookbookАнтония Полухина, ISBN 9781849514880.

Шаг 1: Создание функтора, который преобразует любой тип в строку и запоминает результат:

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

Шаг 2: Применение<stringize_functor>к каждому элементу в последовательности:

#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;
}

Шаг 3: Использование<stringize>с различными типами:

#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");
}

В этом примере мы сделаем метод<to_long_double>, который преобразует значение Boost. Варианты<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);
}