Boost C++ Libraries

template<typename Target, typename Source>
  Target lexical_cast(const Source& arg);

Returns the result of streaming arg into a standard library string-based stream and then out as a Target object. Where Target is either std::string or std::wstring, stream extraction takes the whole content of the string, including spaces, rather than relying on the default operator>> behavior. If the conversion is unsuccessful, a bad_lexical_cast exception is thrown.

template <typename Target>
  Target lexical_cast(const AnyCharacterType* chars, std::size_t count);

Takes an array of count characters as input parameter and streams them out as a Target object. If the conversion is unsuccessful, a bad_lexical_cast exception is thrown. This call may be useful for processing nonzero terminated array of characters or processing just some part of character array.

The requirements on the argument and result types for both functions are:

The character type of the underlying stream is assumed to be char unless either the Source or the Target requires wide-character streaming, in which case the underlying stream uses wchar_t. Following types also can use char16_t or char32_t for wide-character streaming:

	Important
	Many compilers and runtime libraries fail to make conversions using new Unicode characters. Make sure that the following code compiles and outputs nonzero values, before using new types: std::cout << boost::lexical_cast<std::u32string>(1.0).size() << " " << boost::lexical_cast<std::u16string>(1.0).size();

Where a higher degree of control is required over conversions, std::stringstream and std::wstringstream offer a more appropriate path. Where non-stream-based conversions are required, lexical_cast is the wrong tool for the job and is not special-cased for such scenarios.

class bad_lexical_cast : public std::bad_cast
{
public:
    ... // same member function interface as std::exception
};

Exception used to indicate runtime lexical_cast failure.

boost::lexical_cast remains the main interface for lexical conversions. It must be used by default in most cases. However some developers wish to make their own conversion functions, reusing all the optimizations of the boost::lexical_cast. That's where the boost::conversion::try_lexical_convert function steps in.

try_lexical_convert returns true if conversion succeeded, otherwise returns false. If conversion failed and false was returned, state of result output variable is undefined.

Actually, boost::lexical_cast is implemented using try_lexical_convert:

template <typename Target, typename Source>
inline Target lexical_cast(const Source &arg)
{
    Target result;

    if (!conversion::try_lexical_convert(arg, result))
        throw bad_lexical_cast();

    return result;
}

try_lexical_convert relaxes the CopyConstructible and DefaultConstructible requirements for Target type. Following requirements for Target and Source remain: