std::string text = GetValueFromEdit();
  double d;
  try 
  {
    d = boost::lexical_cast<double>(text);
  } catch(boost::bad_lexical_case&) 
  {
    d = 0;
  }

  // почему нет такого варианта
  if (!boost::lexical_cast<double>(text, d)) 
  {
     d = 0;
  }

  // или какого-нибудь еще

template< typename T, typename U >
boost::optional< T > LexicalCastNoThrow( const U& val )
{
     boost::optional< T > ret;
     try
     {
          ret = boost::lexical_cast< T >( val );
     }
     catch( std::exception& )
     {
///...
     }
     return ret;
}
// ну или посмотреть внутрь и использовать try_lexical_convert
template <typename Target, typename Source>
inline Target lexical_cast(const Source &arg)
{
    Target result;

    if (!boost::conversion::detail::try_lexical_convert(arg, result)) {
        boost::conversion::detail::throw_bad_cast<Source, Target>();
    }

    return result;
}

Exceptions
If no conversion could be performed, an invalid_argument exception is thrown.
If the value read is out of the range of representable values by a double (in some library implementations, this includes underflows), an out_of_range exception is thrown.

RA>  std::string text = GetValueFromEdit();
RA>  double d;
RA>  try 
RA>  {
RA>    d = boost::lexical_cast<double>(text);
RA>  } catch(boost::bad_lexical_case&) 
RA>  {
RA>    d = 0;
RA>  }

RA>  // почему нет такого варианта
RA>  if (!boost::lexical_cast<double>(text, d)) 
RA>  {
RA>     d = 0;
RA>  }

RA>  // или какого-нибудь еще
  
RA>

template<typename Source, typename Target>
Target lexical_cast<Source const& src, boost::system::error_code& error);

boost::system::error_code err;
double const d = lexical_cast<double>(text, err);
if (err)
{
    // handle conversion error
}

std::shared_ptr<A> a = get_pointer_that_can_be_null();
if (a)
{
  a->use_value();
}

std::shared_ptr<A> a = get_pointer_that_can_be_null();
try
{
  a->use_value();
} catch(std::bad_shared_ptr&)
{ // do nothing
}