Uitzonderingen: MFC-macro's en C++ uitzonderingen gebruiken

In dit artikel worden overwegingen besproken voor het schrijven van code die gebruikmaakt van zowel de MFC-macro's voor het afhandelen van uitzonderingen als de C++-trefwoorden voor het verwerken van uitzonderingen.

In dit artikel worden de volgende onderwerpen behandeld:

• Uitzonderingstrefwoorden en macro's combineren

• Blokken proberen binnen catch-blokken

Uitzonderingstrefwoorden en macro's combineren

U kunt MFC-uitzonderingsmacro's en C++-uitzonderingstrefwoorden in hetzelfde programma combineren. U kunt MFC-macro's echter niet combineren met C++-uitzonderingstrefwoorden in hetzelfde blok, omdat de macro's uitzonderingsobjecten automatisch verwijderen wanneer ze buiten het bereik vallen, terwijl code met behulp van de trefwoorden voor uitzonderingsafhandeling niet. Zie het artikel Uitzonderingen: Uitzonderingen vangen en verwijderen voor meer informatie.

Het belangrijkste verschil tussen de macro's en de trefwoorden is dat de macro's automatisch een opgepakte uitzondering verwijderen wanneer de uitzondering buiten het bereik valt. Code die de trefwoorden gebruikt, doet dat niet; uitzonderingen die in een catch-blok worden gevangen, moeten expliciet worden verwijderd. Het combineren van macro's en C++-uitzonderingstrefwoorden kan geheugenlekken veroorzaken wanneer een uitzonderingsobject niet wordt verwijderd of heapbeschadiging wanneer een uitzondering twee keer wordt verwijderd.

Met de volgende code wordt bijvoorbeeld de uitzonderingspointer ongeldig:

TRY
{
   TRY
   {
   // Do something to throw an exception.
   AfxThrowUserException();
}
CATCH(CException, e)  // The "inner" catch block
{
   throw;  // Invalid attempt to throw exception
         // to the outer catch block below.
}
END_CATCH
}
CATCH(CException, e)  // The "outer" catch block
{
   // Pointer e is invalid because
   // it was deleted in the inner catch block.
}
END_CATCH

Het probleem treedt op omdat e wordt verwijderd wanneer de uitvoering uit het "inner" CATCH-blok valt. Als u de THROW_LAST macro gebruikt in plaats van de THROW instructie, ontvangt het 'outer' CATCH-blok een geldige aanwijzer:

TRY
{
   TRY
   {
   // Do something to throw an exception.
   AfxThrowUserException();
}
CATCH(CException, e)  // The "inner" catch block
{
   THROW_LAST(); // Throw exception to the outer catch block below.
}
END_CATCH
}
CATCH(CException, e)  // The "outer" catch block
{
   // Pointer e is valid because
   // THROW_LAST() was used.
}
END_CATCH

Try-blokken binnen catch-blokken

U kunt de huidige uitzondering niet opnieuw genereren vanuit een blok dat zich in een tryCATCH-blok bevindt . Het volgende voorbeeld is ongeldig:

TRY
{
   // Do something to throw an exception.
   AfxThrowUserException();
}
CATCH(CException, e)
{
   try
   {
      throw;  // Wrong.  Causes e (the exception 
            // being thrown) to be deleted.
   }
   catch (CException* exception)
   {
      exception->ReportError();
   }
}
END_CATCH

Zie Uitzonderingen: Uitzonderingsinhoud onderzoeken voor meer informatie.

Zie ook

afhandeling van uitzonderingen