Attraper Plusieurs Personnalisée Exceptions? - C++

Vous devez créer une base de classe d'exception et l'ensemble de vos exceptions spécifiques en découlent:

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

Ensuite, vous pouvez attrapez-les tous dans un seul bloc catch:

catch (const BaseException& e) { }

Si vous voulez être en mesure d'appeler GetMessage, vous aurez besoin de:

• place que logique dans BaseException, ou
• faire GetMessage une fonction membre virtuelle dans BaseException et de le remplacer dans chacune des dérivées des classes d'exception.

Vous pourriez aussi envisager d'avoir votre exceptions dériver de celui de la bibliothèque standard exceptions, comme std::runtime_error et l'utilisation de la idiomatiques what() fonction de membre au lieu de GetMessage().

J'ai eu un problème similaire aujourd'hui, mais il s'est avéré que je n'avais pas besoin de ma solution pour résoudre mon problème. Honnêtement, je ne pouvais pas penser à de véritables cas d'utilisation (exploitation forestière?), et je n'ai pas trouver beaucoup de l'utiliser dans mon code.

De toute façon, c'est une approche de type listes (nécessite le C++11). Je pense que l'avantage de cette approche est qu'il n'y a pas besoin d'avoir une classe de base commune pour la coutume des exceptions (sauf pour les std::exception, peut-être?). En d'autres termes, il n'est pas intrusif à l'exception de la hiérarchie.

Il pourrait y avoir quelques petites erreurs que je ne suis pas au courant de.

#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.
}
}

Je rencontre le même problème et voici ce que j'ai:

  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;
}

Dans mon cas, la fonction retourne quand elle n'est pas une exception. Donc je n'ai pas vraiment faire quelque chose à l'intérieur de l'attraper, mais peut faire le travail à l'extérieur de l'essayer.