Exceptions : conversion à partir de macros d’exception MFC

Il s’agit d’une rubrique avancée.

Cet article explique comment convertir du code existant écrit avec des macros de classe Microsoft Foundation ( TRY, CATCH, THROW, et ainsi de suite) pour utiliser les mots clés tryde gestion des exceptions C++ , catchet throw. Les sujets abordés sont les suivants :

• Avantages de conversion

• Conversion de code avec des macros d’exception pour utiliser des exceptions C++

Avantages de la conversion

Vous n’avez probablement pas besoin de convertir du code existant, bien que vous soyez conscient des différences entre les implémentations de macros dans MFC version 3.0 et les implémentations dans les versions antérieures. Ces différences et modifications ultérieures du comportement du code sont décrites dans Exceptions : modifications apportées aux macros d’exception dans la version 3.0.

Les principaux avantages de la conversion sont les suivants :

• Le code qui utilise les mots clés de gestion des exceptions C++ se compile sur une .EXE ou un .DLL légèrement plus petit.

• Les mots clés de gestion des exceptions C++ sont plus polyvalents : ils peuvent gérer les exceptions de n’importe quel type de données qui peut être copié (int, floatchar, etc.), tandis que les macros gèrent uniquement les exceptions de classes CException et de classes dérivées de celui-ci.

La principale différence entre les macros et les mots clés est que le code utilisant les macros « automatiquement » supprime une exception interceptée lorsque l’exception sort de l’étendue. Le code utilisant les mots clés ne le fait pas. Vous devez donc supprimer explicitement une exception interceptée. Pour plus d’informations, consultez l’article Exceptions : Intercepter et supprimer des exceptions.

Une autre différence est la syntaxe. La syntaxe des macros et des mots clés diffère en trois points :

1. Arguments de macro et déclarations d’exception :

   Un appel de macro CATCH a la syntaxe suivante :

   CATCH(exception_class, exception_object_pointer_name)

   Notez la virgule entre le nom de la classe et le nom du pointeur d’objet.

   La déclaration d’exception pour le catch mot clé utilise cette syntaxe :

   catch(exception_type exception_name)

   Cette instruction de déclaration d’exception indique le type d’exception que les handles de bloc catch.

2. Délimitation des blocs catch :

   Avec les macros, la macro CATCH (avec ses arguments) commence le premier bloc catch ; la macro AND_CATCH commence les blocs catch suivants, et la macro END_CATCH met fin à la séquence de blocs catch.

   Avec les mots clés, le catch mot clé (avec sa déclaration d’exception) commence chaque bloc catch. Il n’existe aucun équivalent à la macro END_CATCH  ; le bloc catch se termine par son accolade fermante.

3. Expression levée :

   Les macros utilisent THROW_LAST pour lever à nouveau l’exception actuelle. Le throw mot clé, sans argument, a le même effet.

Exécution de la conversion

Pour convertir du code à l’aide de macros pour utiliser les mots clés de gestion des exceptions C++

1. Recherchez toutes les occurrences des macros MFC TRY, CATCH, AND_CATCH, END_CATCH, THROW et THROW_LAST.

2. Remplacez ou supprimez toutes les occurrences des macros suivantes :

   TRY (remplacer par try)

   CATCH (Remplacez-le par catch)

   AND_CATCH (remplacer par catch)

   END_CATCH (supprimer)

   THROW (Remplacer par throw)

   THROW_LAST (remplacer par throw)

3. Modifiez les arguments de macro afin qu’ils forment des déclarations d’exception valides.

   Par exemple, modifiez

   CATCH(CException, e)
   

   à

   catch (CException* e)
   

4. Modifiez le code dans les blocs catch afin qu’il supprime les objets d’exception si nécessaire. Pour plus d’informations, consultez l’article Exceptions : Intercepter et supprimer des exceptions.

Voici un exemple de code de gestion des exceptions à l’aide de macros d’exception MFC. Notez que, étant donné que le code de l’exemple suivant utilise les macros, l’exception e est supprimée automatiquement :

TRY
{
   // Do something to throw an exception.
   AfxThrowUserException();
}
CATCH(CException, e)
{
   if (m_bPassExceptionsUp)
      THROW_LAST();

   if (m_bReturnFromThisFunction)
      return;

   // Not necessary to delete the exception e.
}
END_CATCH

Le code de l’exemple suivant utilise les mots clés d’exception C++. L’exception doit donc être supprimée explicitement :

try
{
   // Do something to throw an exception.
   AfxThrowUserException();
}
catch (CException* e)
{
   if (m_bPassExceptionsUp)
      throw;

   if (m_bThrowDifferentException)
   {
      e->Delete();
      throw new CMyOtherException;
   }

   if (m_bReturnFromThisFunction)
   {
      e->Delete();
      return;
   }

   e->Delete();
}

Pour plus d’informations, consultez Exceptions : Utilisation des macros MFC et des exceptions C++.

Voir aussi

gestion des exceptions