Exceptions : conversion à partir de macros d'exception MFC

  • Article

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 mot clé de trygestion des exceptions C++ , catchet throw. Les sujets abordés sont les suivants :

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 la gestion des exceptions C++ mot clé s se compile sur un fichier .EXE ou .DLL légèrement plus petit.

  • Les mot clé de gestion des exceptions C++ sont plus polyvalents : ils peuvent gérer les exceptions de tout type de données qui peut être copié (int, float, charetc.), tandis que les macros gèrent uniquement les exceptions de classe CException et de classes dérivées.

La principale différence entre les macros et les mot clé est que le code utilisant les macros « automatiquement » supprime une exception interceptée lorsque l’exception sort de l’étendue. Le code utilisant les mot clé 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 mot clé 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 l’mot clé catch 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 mot clé, la 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 mot clé 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 l’exception C++ mot clé s. 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