Question

我正在编写一个函数，该函数调用可能为了初始化const成员而抛出的函数。问题是：如果我将初始化放在try块中，当它超出范围时会被删除。如果我把初始化放在try块之外，我就无法捕获异常。解决它的方法是：

double functionA()
{
  double a;
  try
  {
    a=functionThatMayThrow();
  }
  catch(std::except&p)
  {
    std::throw_with_nested(std::runtime_error(__func__);
  }
  const double b=a;
  //More code that uses b and computes x
  return x; 
}

我想知道是否有更好的方法可以做到这一点。类似的东西：

double functionA()
{
  const double b=functionThatMayThrow();
  //catch the exception somehow and rethrow with nested information

  //Unchanged
  //More code that uses b and computes x
  return x; 
}

也许我只是采取了一种完全错误的方法解决问题。你能给我任何建议吗？任何boost或c ++ 11相关解决方案也都很好。

Answer 1

要向任何传递的异常添加一些跟踪信息，¹可以执行此操作：

auto func_A()
    -> double
{
    try
    {
        // The complete original function body.

        double const a = 2*some_func();
        return a/2;
    }
    catch( ... )
    {
        throw_with_nested( runtime_error( __func__ ) );
    }
}

但重复说到处都可能有点单调乏味且容易出错，因此您可能希望集中逻辑，而是将功能表达为例如。

auto func_A()
    -> double
{
    return with_trace( __func__, [&]() -> double
    {
        // The complete original function body.

        double const a = 2*some_func();
        return a/2;
    } );
}

现在这需要一些支持机制，包括下调和上调，例如

#include <exception>    // std::throw_with_nested
#include <iostream>
#include <stdexcept>    // std::runtime_error, std::exception
#include <stdlib.h>     // EXIT_FAILURE, EXIT_SUCCESS
#include <string>       // std::string
#include <vector>       // std::vector

namespace cppx {
    using std::runtime_error;
    using std::throw_with_nested;

    template< class Func >
    auto with_trace( char const* const func_name, Func const body )
        -> decltype( body() )
    {
        try
        {
            return body();
        }
        catch( ... )
        {
            throw_with_nested( runtime_error( func_name ) );
        }
    }

    namespace x_io
    {
        using std::endl;
        using std::exception;
        using std::cerr;            // For client code.
        using std::ostream;
        using std::rethrow_if_nested;

        namespace impl {
            void print_on( ostream& stream, exception const& x, bool const is_nested )
            {
                stream << (is_nested? ">" : "!") << x.what() << endl;
                try
                {
                    rethrow_if_nested( x );
                }
                catch( exception const& nested_x )
                {
                    print_on( stream, nested_x, true );
                }
                catch( ... )
                {
                    stream << "<unknown exception type>" << endl;
                }
            }
        }  // namespace impl

        auto operator<<( ostream& stream, exception const& x )
            -> ostream&
        {
            impl::print_on( stream, x, false );
            return stream;
        }
    }    // namespace x_io
}  // namespace cppx

namespace my {
    using std::runtime_error;
    using std::string;
    using std::vector;
    using cppx::with_trace;

    bool fail_is_good;

    auto some_func()
        -> double
    {
        if( fail_is_good ) { throw runtime_error( "some_func" ); }
        return 3.14;
    }

    auto func_A()
        -> double
    {
        return with_trace( __func__, [&]() -> double
        {
            double const a = 2*some_func();
            return a/2;
        } );
    }

    void cpp_main( vector< string > const& args )
    {
        using std::cout; using std::endl;
        my::fail_is_good = (args.size() > 1);
        cout << func_A() << endl;
    }
}  // namespace my

auto main( int argc, char* argv[] )
    -> int
{
    using std::exception; using std::string; using std::vector;
    try
    {
        my::cpp_main( vector<string>( argv, argv + argc ) );
        return EXIT_SUCCESS;
    }
    catch( exception const& x )
    {
        using namespace cppx::x_io;
        cerr << x << endl;
    }
    return EXIT_FAILURE;
}

^{¹）不幸的是，即使在2013年11月的CTP版本中，Visual C ++ 12.0（2013）也不支持std::throw_with_nested。只需实施即可轻松添加此类支持。此外，我记得它不支持__func__，但该宏也很容易定义。}

使用可能抛出c ++的函数初始化const对象

1 个答案: