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

This is the documentation for an old version of Boost. Click here to view this page for the latest version.

Alternative Interface

"It's not a question of happiness, it's a requirement. Consider the alternative” Doug Horton

As it was indicated previously boost::optional is the actual type returned by the boost::convert() main interface:

boost::optional<TypeOut> boost::convert(TypeIn const&, Converter const&);

The signature is functionally-complete, routinely elided during compilation and is the most efficient in deploying the underlying converter. That said, the following alternative (and arguably more conventional) interface might be potentially more suitable for certain deployment scenarios (or due to personal preferences):

TypeOut convert(TypeIn const&, Converter const&, TypeOut const& fallback_value);
TypeOut convert(TypeIn const&, Converter const&, Functor const& fallback_functor);
TypeOut convert(TypeIn const&, Converter const&, boost::throw_on_failure);

It still provides unambigous behavior and readability, full support for various program flows and various degrees of conversion-failure detection and processing and can be deployed in a similar fashion as follows:

struct fallback_func
    int operator()() const { log("Failed to convert"); return 42; }

// Error-processing behavior are specified unambiguously and uniformly.
// a) i1: Returns the provided fallback value;
// b) i2: Calls the provided failure-processing function;
// c) i3: Throws an exception.

int i1 = convert<int>(str, cnv, fallback_value);
int i2 = convert<int>(str, cnv, fallback_func());

    // Throwing behavior specified explicitly rather than implied.
    int i3 = convert<int>(str, cnv, boost::throw_on_failure);
catch (boost::bad_optional_access const&)
  // Handle failed conversion.

Still, the described interfaces are convenience wrappers around the main interface which provides the described behavior with:

int m1 = convert<int>(str, cnv).value_or(fallback_value);
int m2 = convert<int>(str, cnv).value_or_eval(fallback_func());
int m3 = convert<int>(str, cnv).value();

or with the default converter defined:

struct boost::cnv::by_default : public boost::cnv::cstream {};

int n1 = convert<int>(str).value_or(fallback_value);
int n2 = convert<int>(str).value_or_eval(fallback_func());
int n3 = convert<int>(str).value();