Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world. Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

Introduction
PrevUpHomeNext

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"


PrevUpHomeNext