la capture de std::exception par référence?

J'ai une question idiote. J'ai lu cet article à propos de std::exception http://www.cplusplus.com/doc/tutorial/exceptions/

Sur catch (exception& e), il dit:

Nous avons placé un gestionnaire de captures exception des objets par référence (avis de l'esperluette & d'après le type), par ce que les captures également les classes dérivées à partir d'exception, à l'instar de notre myex un objet de la classe myexception.

Est-ce à dire qu'en utilisant "&", vous pouvez aussi assister à l'exception de la classe parent? Je pensais que & prédéfini dans std::exception parce que c'est mieux de passer e (std::exception) comme référence de l'objet.

Je ne comprends pas votre dernier paragraphe. Le passage par référence n'a rien à voir avec les exceptions et qu'il est fondamental en C++ pour permettre le polymorphisme d'exécution.
La réponse est non, les objets que vous pouvez attraper doit être dérivé du type d'exception vous attraper, comme vous l'avez mentionné dans votre post. Ce qui témoigne de la relation " EST-UN. Vous ne pouvez pas attraper un parent de la classe si vous ne spécifiez les enfants dans les clauses catch.

OriginalL'auteur user853069 | 2011-07-20

  1. 52

    La raison de l'utilisation & avec des exceptions n'est pas tellement le polymorphisme d'éviter les trancher. Si vous avez été de ne pas utiliser &, C++ serait tenter de copier la levée d'une exception, dans une nouvelle std::exception, potentiellement perdre de l'information dans le processus. Exemple:

    #include <stdexcept>
#include <iostream>

class my_exception : public std::exception {
  virtual const char *what() const throw() {
    return "Hello, world!";
  }
};

int main() {
  try {
    throw my_exception();
  } catch (std::exception e) {
    std::cout << e.what() << std::endl;
  }
  return 0;
}

    Cela permettra d'imprimer le message par défaut pour std::exception (dans mon cas, St9exception) plutôt que de Hello, world!, parce que l'objet exception d'origine a été perdu par tranchage. Si nous changeons d'une &:

    #include <stdexcept>
#include <iostream>

class my_exception : public std::exception {
  virtual const char *what() const throw() {
    return "Hello, world!";
  }
};

int main() {
  try {
    throw my_exception();
  } catch (std::exception &e) {
    std::cout << e.what() << std::endl;
  }
  return 0;
}

    Maintenant nous faire voir Hello, world!.

    +1; Wow, votre exemple et de la réponse de l'air remarquablement semblable à la mienne. Êtes-vous assis derrière moi? 😉
    nan, je pense que c'est juste le moyen le plus simple pour illustrer le problème 🙂
    +bdonlan je ne comprends pas que virtual const char *what() const throw() { les deux fonctions? ce() & throw() pouvez-vous expliquer cette syntaxe de la fonction. Je n'ai pas vu ça avant.
    Il définit une fonction virtuelle nommée quoi, le retour const char *, qui peut être appelée sur un const objet (la deuxième const) et qui ne lève des exceptions throw(). Ce est la bonne façon de remplacer what() sur std::exception
    Pour être tatillon: Depuis what() est défini comme virtuelle std::exception, vous pouvez utiliser const char *what() const throw() override ou mieux const char *what() const throw() final.

    OriginalL'auteur bdonlan

  2. 8

    Est-ce à dire qu'en utilisant "&", vous pouvez aussi assister à l'exception de la classe parent?

    Non, ce n'est pas augmenter la portée de l'endroit où vous pourrez attraper les exceptions (par exemple, à partir de la classe mère de la classe qui contient le try/catch code).

    Il n'augmente pas aussi les types d'exceptions qui peuvent être pris, par rapport à la chasse par valeur (catch(std::exception e) sans & - vous aurez toujours attraper chaque exception est std::exception ou en dérive).

    Ce qu'il augmente la quantité de données que vous obtenez quand vous attrapez l'exception.

    Si une exception est levée, qui dérive de std::exception, et vous l'attrapez par la valeur, alors vous êtes en jetant tout comportement supplémentaire dans cette classe d'exception. Il rompt le polymorphisme sur la classe d'exception, en raison de Trancher.

    Un exemple:

    class MyException : public std::exception
{
public:
    virtual const char* what() const
    {
        return "hello, from my exception!";
    }
};

//...

try
{
    throw MyException();
}
catch(std::exception& e)
{
    //This will print "hello, from my exception!"
    std::cout << e.what() << "\n";
}

//...

try
{
    throw MyException();
}
catch(std::exception e)
{
    //This will print "Unknown exception"
    std::cout << e.what() << "\n";
}

    OriginalL'auteur Merlyn Morgan-Graham

  3. 2

    Pas de la & n'a absolument aucune incidence sur le caractère polymorphe des gestionnaires d'exception. Leur formulation est mauvaise, il ne semble indiquer que le & est en quelque sorte responsable. Ce n'est pas le cas. Vous avez raison, & passe uniquement par la référence qui est un peu plus efficace.

    Aussi comme une règle générale, vous devriez vraiment essayer d'éviter cplusplus.com.

    Lien mis à jour: Quel est le problème avec cplusplus.com

    Le découpage est bien plus importante que l'efficacité...
    lien cassé?
    hmm, il semble qu'ils l'ont supprimé l'article, j'ai mis à jour le lien.

    OriginalL'auteur Chris Eberle

  4. 0

    À l'aide de référence à l'exception peut réduire les objets temporaires créés, et il permet également de maintenir le polymorphisme.

    OriginalL'auteur Jack