C ++ manipulation d'exception

Les exceptions sont les questions de procédure soulevées lors de l'exécution. C ++ exception se réfère à se produit spécial lorsque le programme est en cours d'exécution, tels que les tentatives de diviser par opération zéro.

Exception fournit un moyen de contrôle du programme de transfert. C ++ traitement d'exception comporte troismots - clés:essayer, attraper, lancer.

jeter: Lorsque des problèmes surviennent, le programme lancera une exception.Ceci est fait en utilisant le mot cléthrow pour terminer.
attraper: où vous voulez régler le problème, une exception est interceptée par un gestionnaire d'exception.captures mot - clé est utilisé pour intercepter des exceptions.
essayez: essayezle code de bloc identifie une exception spécifique est activée. Derrière elle est généralement suivie par un ou plusieurs blocs catch.

S'il y a un bloc génère une exception, attraper la méthode d'exception utiliseessayer de mots - clés de capture.essayez de placer un bloc de code pourrait lancer une exception, essayez le code de bloc est connu sous le nom de code protégé. Utilisez try / instruction catch syntaxe suivante:

try
{
   // 保护代码
}catch( ExceptionName e1 )
{
   // catch 块
}catch( ExceptionName e2 )
{
   // catch 块
}catch( ExceptionName eN )
{
   // catch 块
}

Si vousessayez bloc dans différents contextes va lancer une exception différente, cette fois vous pouvez essayer de lister plusieurs déclarations de capturespour attraper différents types d'exceptions.

Jeter une exception

Vous pouvez utiliser l'instructionthrow partout dans le bloc de code renvoie une exception.instruction throw Opérande peut être tout type de résultat de l'expression d'expression détermine le type d'exception levée.

Ce qui suit est une exception Essayer zéro divisé par des exemples:

double division(int a, int b)
{
   if( b == 0 )
   {
      throw "Division by zero condition!";
   }
   return (a/b);
}

Attrapez l'exception

bloccatch derrière lebloctrypour capturer des exceptions. Vous pouvez spécifier le type d'exception que vous voulez capturer, qui est déclarée par l'exception entre parenthèses après les décisions prises par mot clé.

try
{
   // 保护代码
}catch( ExceptionName e )
{
  // 处理 ExceptionName 异常的代码
}

Le code ci - dessus capturer une exception de typeExceptionName.Si vous voulez attraper bloc peut gérer tout type d'exception levée bloc try, vous devez utiliser l'exception dans ellipsis parenthèses ... déclaration, comme suit:

try
{
   // 保护代码
}catch(...)
{
  // 能处理任何异常的代码
}

Voici un exemple d'une division par zéro déclenche une exception, et l'exception est pris dans le bloc catch.

#include <iostream>
using namespace std;

double division(int a, int b)
{
   if( b == 0 )
   {
      throw "Division by zero condition!";
   }
   return (a/b);
}

int main ()
{
   int x = 50;
   int y = 0;
   double z = 0;
 
   try {
     z = division(x, y);
     cout << z << endl;
   }catch (const char* msg) {
     cerr << msg << endl;
   }

   return 0;
}

Depuis que nous jetons un typeconst char * exception, donc, lorsque la capture cette exception, nous devons utiliser const char * dans le bloc catch.Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants:

Division by zero condition!

exceptions standard de C

C ++ fournit un ensemble d'exceptions standard définies dans<exception>, nous pouvons utiliser ces exceptions standard dans le programme.Ils sont basés sur la hiérarchie des classes parent-enfant organisé comme suit:

Le tableau suivant est une description de chacun de la hiérarchie ci-dessus semblent anormales:

异常	描述
std::exception	该异常是所有标准 C++ 异常的父类。
std::bad_alloc	该异常可以通过new抛出。
std::bad_cast	该异常可以通过dynamic_cast抛出。
std::bad_exception	这在处理 C++ 程序中无法预期的异常时非常有用。
std::bad_typeid	该异常可以通过typeid抛出。
std::logic_error	理论上可以通过读取代码来检测到的异常。
std::domain_error	当使用了一个无效的数学域时，会抛出该异常。
std::invalid_argument	当使用了无效的参数时，会抛出该异常。
std::length_error	当创建了太长的 std::string 时，会抛出该异常。
std::out_of_range	该异常可以通过方法抛出，例如 std::vector 和 std::bitset<>::operator[]()。
std::runtime_error	理论上不可以通过读取代码来检测到的异常。
std::overflow_error	当发生数学上溢时，会抛出该异常。
std::range_error	当尝试存储超出范围的值时，会抛出该异常。
std::underflow_error	当发生数学下溢时，会抛出该异常。

Définir de nouvelles exceptions

Vous pouvez définir une nouvelle exception par héritage de classed'exception et la surcharge.L'exemple suivant montre comment utiliser la classe std :: exception à mettre en œuvre leurs propres exceptions:

#include <iostream>
#include <exception>
using namespace std;

struct MyException : public exception
{
  const char * what () const throw ()
  {
    return "C++ Exception";
  }
};
 
int main()
{
  try
  {
    throw MyException();
  }
  catch(MyException& e)
  {
    std::cout << "MyException caught" << std::endl;
    std::cout << e.what() << std::endl;
  }
  catch(std::exception& e)
  {
    //其他的错误
  }
}

On obtient les résultats suivants:

MyException caught
C++ Exception

Ici, la méthode que () est une classe d'exception publique à condition qu'il ait été surchargé toutes les classes d'exception sous.Ceci renverra la cause de cette exception générée.

Précédent: C ++ fichiers et flux

Suivant: C ++ mémoire dynamique

C++ cours

C++ Object-Oriented

C++ Tutorial avancée

C++ dépôt

C ++ manipulation d'exception

Jeter une exception

Attrapez l'exception

exceptions standard de C

Définir de nouvelles exceptions