С++ выводит тип вложенного исключения

Введение:

Дано:

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 текущего исключения.

Я ищу (переносимые) идеи и решения, которые позволяют мне восстанавливать typeid (X) из "исключения с неизвестным именем", созданного стандартной библиотекой во время std::rethrow_exception.

С++ 14 и С++ 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()));

ОТВЕТЫ

Ответ 1

Один из способов - последовательно использовать собственный 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, чтобы поддерживать то, что вы хотите.

Ответ 2

Адаптировано print_exception из http://en.cppreference.com/w/cpp/error/nested_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);
}

Демо

Ответ 3

Спасибо ребятам, которые ответили.

В конце концов, я почувствовал, что самым надежным способом было развязать результат typeid::name() и удалить любые "вложенные" части имени типа.

У меня получилось создать карту регистрации исключений, но для этого потребовались нестандартные механизмы броска и реверберации для привязки к карте.

Это небольшая платформа, но она может быть инкапсулирована в библиотечную функцию:

#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());
}