exceptions : Convertir des macros d'exception MFC

Article
06/10/2015

Ceci est une rubrique avancée.

Cet article explique comment convertir le code existant entre des macros de Microsoft Foundation Class ( TRY, CATCH, THROW, etc. — pour utiliser les mots clés de gestion des exceptions C++ try, catch, et throw. Les rubriques traitées ici sont les suivantes :

Avantages de conversion
Conversion de code avec des macros d'exception pour utiliser des exceptions C++

Avantages de conversion

Vous n'avez probablement pas besoin de convertir le code existant, bien que vous devriez tenir compte des différences entre les implémentations de macro dans la version 3,0 de MFC et les implémentations dans les versions antérieures. Ces différences et les modifications qui s'en suivent du comportement du code sont décrites dans Exceptions : Modifications des macros d'exception de la version 3,0.

Les avantages de conversion sont :

Le code qui utilise les compilations de mots clés de gestion des exceptions C++ se compile en un .EXE ou un .DLL légèrement plus petit.
Les mots clés de gestion des exceptions C++ sont plus souples : Ils peuvent gérer les exceptions de tout type de données qui peuvent être copiées (int, float, char, etc.), tandis que les macros gèrent uniquement les exceptions de la classe CException et des classes dérivées de celle-ci.

La différence majeure entre les macros et les mots clés est qu'utiliser les macros dans le code supprime "automatiquement" une exception interceptée lorsque l'exception passe hors de portée. Ce n'est pas le cas en utilisant les mots clés en codant, vous devez explicitement supprimer une exception interceptée. Pour plus d'informations, consultez l'article Exceptions : Intercepter et Supprimer des exceptions.

L'autre différence est la syntaxe. La syntaxe des macros et celle des mots clés différent à trois égards :

Les arguments de macro et déclarations d'exception :

Une invocation de macro CATCH présente la syntaxe suivante :

CATCH( classe_d_exception, nom_pointeur_objet_exception )

Notez la virgule entre le nom de classe et le nom du pointeur de l'objet.

La déclaration d'exception du mot clé catch utilise cette syntaxe :

catch( type_exception nom_exception**)**

Cette instruction de déclaration d'exception indique le type d'exception que le bloc CATCH gère.
Délimitation des blocs CATCH :

Avec les macros, la macro de CATCH (avec ses arguments) démarre le premier bloc CATCH ; la macro AND_CATCH démarre les blocs CATCH suivants, et la macro END_CATCH termine la séquence de blocs CATCH.

Avec les mots clés, le mot clé catch (avec sa déclaration d'exception) démarre chaque bloc CATCH. Il n'y a pas de contrepartie à END_CATCH; le bloc CATCH se termine avec l'accolade fermante.
L'expression throw :

Les macros utilisent THROW_LAST pour relancer l'exception actuelle. Le mot clé throw, sans l'argument, a le même effet.

Effectuer la conversion

Pour convertir du code utilisant des macros et utiliser les mots clés de gestion des exceptions C++

Recherchez toutes les occurrences des macros MFC TRY, CATCH, AND_CATCH, END_CATCH, THROW, et THROW_LAST.
Remplacez ou supprimez toutes les occurrences des macros suivantes :

TRY   (remplacez le par try)

CATCH (Remplacez-le par catch)

AND_CATCH   (Remplacez le par catch)

END_CATCH (supprimez le)

THROW   (Remplacez le par throw)

THROW_LAST   (Remplacez le par throw)
Modifiez les arguments des macro afin qu'ils constituent des déclarations valides d'exception.

Par exemple, changez
```
CATCH(CException, e)
```
en
```
catch(CException* e)
```
Modifiez le code dans les blocs CATCH afin qu'il supprime les objets d'exception au besoin. Pour plus d'informations, consultez l'article Exceptions : Intercepter et Supprimer des exceptions.

Voici un exemple de code de gestion des exceptions utilisant les macros d'exception de MFC. Notez que puisque le code dans l'exemple suivant utilise des 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 dans l'exemple suivant utilise des mots clés d'exception C++, l'exception doit ê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 : À l'aide de la macro MFC et les exceptions C++.

Voir aussi

Concepts

gestion des exceptions dans MFC

Partager via