Introduction

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.

Boost.Convert provides new and familiar conversion/transformation-related functionality such as:

means to deploy types that do not meet the Default Constructibility requirement;
four types of the conversion-failure detection:
- as part of the same process flow -- basic and generic;
- as a branched process flow -- exception-based and function-based;
the choice of immediate or delayed exception-throwing and non-throwing conversion-failure processing;
flexibility of conversion-failure processing via:
- an exception thrown;
- the fallback value returned;
- the fallback function called;
support for standard algorithms.

Boost.Convert consists of two components:

the boost::convert() interface;
an extendible collection of pluggable converters.

The boost::convert() interface

advertises, provides and ensures certain consistent behavior;
unifies and provides one consistent interface to various conversion facilities.

The collection of pluggable converters is independent of the boost::convert() API facade and is designed to be extendible and extended over time. Currently the following converters are provided:

boost::lexical_cast-based,
printf/scanf-based,
strtol-inspired,
std::stringstream-based,
boost::spirit-based.

The converters provide new and familiar functionality and demonstrate how existing and independent conversion facilities might be incorporated in to the Boost.Convert framework. For example, the std::stream-based converter draws on the standard std::streams functionality and provides:

string-to-type and type-to-string conversions;
formatting support (std::ios-based precision, base, upper/lower-case, scientific, etc.);
support for different locales;
char and wchar_t support.

The following code demonstrates conversion of an array of integers from their textual hexadecimal representation. It assigns -1 to those which fail to convert:

boost::array<char const*, 3> strs = {{ " 5", "0XF", "not an int" }};
std::vector<int>             ints;
boost::cnv::cstream           cnv;

// Configure converter to read hexadecimal, skip (leading) white spaces.
cnv(std::hex)(std::skipws);

std::transform(strs.begin(), strs.end(), std::back_inserter(ints),
    boost::cnv::apply<int>(boost::cref(cnv)).value_or(-1));

BOOST_TEST(ints.size() == 3); // Number of values processed.
BOOST_TEST(ints[0] ==  5);    // " 5"
BOOST_TEST(ints[1] == 15);    // "0XF"
BOOST_TEST(ints[2] == -1);    // "not an int"