Question

简介：

下式给出：

struct X : std::runtime_error {
  using std::runtime_error::runtime_error;
};

当我们调用std::throw_with_nested(X("foo"))时，实际抛出的内容不是X。它是某种类型，源自X和std::nested_exception。

因此，以下断言将失败：

const std::type_info *a = nullptr, *b = nullptr;
try
{
  throw X("1");
}
catch(X& x) {
  a = std::addressof(typeid(x));
  try {
    std::throw_with_nested(X("2"));
  }
  catch(X& x) {
    b = std::addressof(typeid(x));
  }
}
assert(std::string(a->name()) == std::string(b->name()));

我想做的是推断这两个例外是相关的。

首次尝试：

        std::type_index
        deduce_exception_type(const std::exception* pe)
        {
            if (auto pnested = dynamic_cast<const std::nested_exception*>(pe))
            {
                try {
                    std::rethrow_exception(pnested->nested_ptr());
                }
                catch(const std::exception& e)
                {
                    return deduce_exception_type(std::addressof(e));
                }
            }
            else {
                return typeid(*pe);
            }
        }

这会失败，因为std::nested_exception::nested_ptr()返回指向该行下一个异常的指针，而不是当前异常的X接口。

我正在寻找（便携式）想法和解决方案，这些想法和解决方案允许我在std::rethrow_exception期间从标准库抛出的'名称未知的异常'中恢复typeid（X）。

c ++ 14和c ++ 1z很好。

为什么：

因为我希望能够解开一个完整的异常层次结构并在rpc会话中传输它，所以请填写异常类型名称。

理想情况下，我不希望编写一个包含系统中每种异常类型的catch块，这种异常类型必须通过派生深度进行弱排序。

预期功能的另一个例子（以及为什么我的方法不起作用的说明）：

const std::type_info *b = nullptr;
try
{
  throw std::runtime_error("1");
}
catch(std::exception&) {
  try {
    std::throw_with_nested(X("2"));
  }
  catch(X& x) {
    // PROBLEM HERE <<== X& catches a std::_1::__nested<X>, which 
    //                is derived from X and std::nested_exception
    b = std::addressof(typeid(x));
  }
}
assert(std::string(typeid(X).name()) == std::string(b->name()));

Answer 1

改编自http://en.cppreference.com/w/cpp/error/nested_exception的print_exception：

const std::type_info&
deduce_exception_type(const std::exception& e)
{
    try {
        std::rethrow_if_nested(e);
    } catch(const std::exception& inner_e) {
        return deduce_exception_type(inner_e);
    } catch(...) {
    }
    return typeid(e);
}

Demo

Answer 2

一种方法是始终使用您自己的throw_with_nested，其中您注入了您想要的功能：

#include <typeinfo>
#include <exception>

struct identifiable_base {
    virtual std::type_info const& type_info() const = 0;
};

template<typename Exception>
struct identifiable_exception: Exception, identifiable_base {
    using Exception::Exception;

    explicit identifiable_exception(Exception base)
        : Exception(std::move(base))
    {}

    std::type_info const& type_info() const override
    {
        // N.B.: this is a static use of typeid
        return typeid(Exception);
    }
};

template<typename Exception>
identifiable_exception<std::decay_t<Exception>> make_identifiable_exception(Exception&& exception)
{ return identifiable_exception<std::decay_t<Exception>> { std::forward<Exception>(exception) }; }

// N.B.: declared with a different name than std::throw_with_nested to avoid ADL mistakes
template<typename Exception>
[[noreturn]] void throw_with_nested_identifiable(Exception&& exception)
{
    std::throw_with_nested(make_identifiable_exception(std::forward<Exception>(exception)));
}

Live On Coliru

只要您想要更多功能，就可以调整identifiable_base和identifiable_exception来支持您想要的功能。

Answer 3

感谢那些回复的人。

最后，我觉得最可靠的方法是对typeid::name()的结果进行解码，并删除typename的任何“嵌套”部分。

我确实在构建异常注册映射，但是这需要非标准的throw和rethrow机制来挂钩映射。

它有点特定于平台，但可以封装在库函数中：

#include <regex>
#include <string>

namespace
{
    std::string remove_nested(std::string demangled)
    {
#if _LIBCPP_VERSION
        static const std::regex re("^std::__nested<(.*)>$");
#elif __GLIBCXX__
        static const std::regex re("^std::_Nested_exception<(.*)>$");
#endif
        std::smatch match;
        if (std::regex_match(demangled, match, re))
        {
            demangled = match[1].str();
        }
        return demangled;
    }
}

我的用例（Exception派生自google::protobuf::Message）：

void populate(Exception& emsg, const std::exception& e)
{
    emsg.set_what(e.what());
    emsg.set_name(remove_nested(demangle(typeid(e))));
    try {
        std::rethrow_if_nested(e);
    }
    catch(std::exception& e)
    {
        auto pnext = emsg.mutable_nested();
        populate(*pnext, e);
    }
    catch(...) {
        auto pnext = emsg.mutable_nested();
        pnext->set_what("unknown error");
        pnext->set_name("unknown");
    }
}

其中demangle()再次根据特定于平台的代码定义。就我而言：

demangled_string demangle(const char* name)
{
    using namespace std::string_literals;

    int status = -4;

    demangled_string::ptr_type ptr {
        abi::__cxa_demangle(name, nullptr, nullptr, &status),
        std::free
    };

    if (status == 0) return { std::move(ptr) };

    switch(status)
    {
        case -1: throw std::bad_alloc();
        case -2: {
            std::string msg = "invalid mangled name~";
            msg += name;
            auto p = (char*)std::malloc(msg.length() + 1);
            strcpy(p, msg.c_str());
            return demangled_string::ptr_type { p, std::free };
        }
        case -3:
            assert(!"invalid argument sent to __cxa_demangle");
            throw std::logic_error("invalid argument sent to __cxa_demangle");
        default:
            assert(!"PANIC! unexpected return value");
            throw std::logic_error("PANIC! unexpected return value");
    }
}

demangled_string demangle(const std::type_info& type)
{
    return demangle(type.name());
}

其中demangled_string是从abi::__cxa_demangle（或类似于Windows）返回的内存的方便包装：

struct demangled_string
{
    using ptr_type = std::unique_ptr<char, void(*)(void*)>;
    demangled_string(ptr_type&& ptr) noexcept;
    const char* c_str() const;
    operator std::string() const;

    std::ostream& write(std::ostream& os) const;
private:
    ptr_type _ptr;
};

demangled_string::demangled_string(ptr_type&& ptr) noexcept
: _ptr(std::move(ptr))
{}

std::ostream& demangled_string::write(std::ostream& os) const
{
    if (_ptr) {
        return os << _ptr.get();
    }
    else {
        return os << "{nullptr}";
    }
}

const char* demangled_string::c_str() const
{
    if (!_ptr)
    {
        throw std::logic_error("demangled_string - zombie object");
    }
    else {
        return _ptr.get();
    }
}

demangled_string::operator std::string() const {
    return std::string(c_str());
}

c ++推导出嵌套异常的类型

3 个答案: