Поймать несколько пользовательских исключений? - С++

Ответ 1

Если у вас несколько типов исключений и предполагается наличие иерархии исключений (и все, полученные публично из какого-либо подкласса std::exception), начинаются с наиболее конкретных и продолжаются до более общих:

try
{
    // throws something
}
catch ( const MostSpecificException& e )
{
    // handle custom exception
}
catch ( const LessSpecificException& e )
{
    // handle custom exception
}
catch ( const std::exception& e )
{
    // standard exceptions
}
catch ( ... )
{
    // everything else
}

С другой стороны, если вас интересует только сообщение об ошибке - throw то же исключение, скажем std::runtime_error с разными сообщениями, а затем catch, что:

try
{
    // code throws some subclass of std::exception
}
catch ( const std::exception& e )
{
    std::cerr << "ERROR: " << e.what() << std::endl;
}

Также помните - бросайте по значению, зацепите ссылку [const].

Ответ 2

Вы должны создать базовый класс исключения и получить из него все ваши конкретные исключения:

class BaseException { };
class HourOutOfRangeException : public BaseException { };
class MinuteOutOfRangeException : public BaseException { };

Затем вы можете поймать все их в одном блоке catch:

catch (const BaseException& e) { }

Если вы хотите иметь возможность звонить GetMessage, вам нужно либо:

• поместите эту логику в BaseException или
• сделать GetMessage виртуальную функцию-член в BaseException и переопределить ее в каждом из производных классов исключений.

Вы также можете подумать о том, что ваши исключения проистекают из одного из стандартных исключений библиотеки, например std::runtime_error и используют функцию-член idiomatic what() вместо GetMessage().

Ответ 3

Выведите все свои исключения из общего базового класса BaseException, который имеет виртуальный метод GetMessage().

Тогда catch(const BaseException& e).

Ответ 4

У меня была аналогичная проблема сегодня, но оказалось, что мне не нужно решение для решения моей проблемы. Честно говоря, я не мог думать о реальных случаях использования (протоколирование?), И я не нашел для него большого смысла в своем коде.

В любом случае, это подход с списками типов (требуется С++ 11). Я думаю, что преимущество этого подхода в том, что нет необходимости иметь общий базовый класс для пользовательских исключений (за исключением std:: exception, может быть?). Другими словами, это не навязчиво для вашей иерархии исключений.

Могут быть некоторые тонкие ошибки, о которых я не знаю.

#include <type_traits>
#include <exception>

/// Helper class to handle multiple specific exception types
/// in cases when inheritance based approach would catch exceptions
/// that are not meant to be caught.
///
/// If the body of exception handling code is the same
/// for several exceptions,
/// these exceptions can be joined into one catch.
///
/// Only message data of the caught exception is provided.
///
/// @tparam T  Exception types.
/// @tparam Ts  At least one more exception type is required.
template <class T, class... Ts>
class MultiCatch;

/// Terminal case that holds the message.
/// ``void`` needs to be given as terminal explicitly.
template <>
class MultiCatch<void> {
 protected:
  explicit MultiCatch(const char* err_msg) : msg(err_msg) {}
  const char* msg;
};

template <class T, class... Ts>
class MultiCatch : public MultiCatch<Ts...> {
  static_assert(std::is_base_of<std::exception, T>::value, "Not an exception");

 public:
  using MultiCatch<Ts...>::MultiCatch;

  /// Implicit conversion from the guest exception.
  MultiCatch(const T& error) : MultiCatch<Ts...>(error.what()) {}  // NOLINT

  /// @returns The message of the original exception.
  const char* what() const noexcept {
    return MultiCatch<void>::msg;
  }
};

/// To avoid explicit ``void`` in the type list.
template <class... Ts>
using OneOf = MultiCatch<Ts..., void>;

/// Contrived example.
void foo() {
  try {
    bar();  // May throw three or more sibling or unrelated exceptions.
  } catch (const OneOf<IOError, OutOfMemory>& err) {
    log() << "External failure: " << err.what();

    throw;  // Throw the original exception.
  }
}

Ответ 5

Когда шаблоны не могут, макросы сохраняют день. Решение взято из Boost. Он кипит до 7 строк кода.

/// @file multicatch.hpp
#include <boost/preprocessor/variadic/to_list.hpp>
#include <boost/preprocessor/list/for_each.hpp>

/// Callers must define CATCH_BODY(err) to handle the error,
/// they can redefine the CATCH itself, but it is not as convenient. 
#define CATCH(R, _, T) \
  catch (T & err) {    \
    CATCH_BODY(err)    \
  }
/// Generates catches for multiple exception types
/// with the same error handling body.
#define MULTICATCH(...) \
  BOOST_PP_LIST_FOR_EACH(CATCH, _, BOOST_PP_VARIADIC_TO_LIST(__VA_ARGS__))
// end of file multicatch.hpp

/// @file app.cc
#include "multicatch.hpp"

// Contrived example.
/// Supply the error handling logic.
#define CATCH_BODY(err)                        \
  log() << "External failure: " << err.what(); \
  throw;

void foo() {
  try {
    bar();  // May throw three or more sibling or unrelated exceptions.
  }
  MULTICATCH(IOError, OutOfMemory)
}

#undef CATCH_BODY

Ответ 6

Я столкнулся с той же проблемой, и вот что я закончил:

  std::shared_ptr<MappedImage> MappedImage::get(const std::string & image_dir,
                                                const std::string & name,
                                                const Packet::Checksum & checksum) {
    try {
      return std::shared_ptr<MappedImage>(images_.at(checksum));
    } catch (std::out_of_range) {
    } catch (std::bad_weak_ptr) {
    }
    std::shared_ptr<MappedImage> img =
      std::make_shared<MappedImage>(image_dir, name, checksum);
    images_[checksum_] = img;
    return img;
  }

В моем случае функция возвращается, когда не получает исключения. Так что на самом деле мне не нужно ничего делать внутри улова, но я могу делать работу вне попытки.

Ответ 7

#include <iostream> 
void test(int x)'
{
try{
if(x==1)
throw (1);
else if(x==2)
    throw (2.0);
}
catch(int a)
{
cout<<"It Integer";
}
catch(double b)
{
cout<<"it Double";
}
}
int main(){
cout<<" x=1";
test(1);
cout<<"X=2";
test(2.0);
return 0;
}'