EXCEPTEX Traps MFC en Win32 gestructureerd uitzonderingen

Vertaalde artikelen Vertaalde artikelen
Artikel ID: 167802 - Bekijk de producten waarop dit artikel van toepassing is.
Alles uitklappen | Alles samenvouwen

Op deze pagina

Samenvatting

EXCEPTEX is een voorbeeld demonstreert technieken voor overlapping van Win32-gestructureerde uitzonderingen en C++ uitzonderingen. Voor C++ uitzonderingen, diverse Help-functies worden geleverd die aantonen hoe te kraken Open de uitzondering veelgebruikte klassen. Gestructureerde uitzonderingen voor Win32 een helper functie wordt verstrekt die het type van Win32-uitzondering geeft gegenereerd.

Het volgende bestanden zijn gedownload van het Microsoft Downloadcentrum Plaats:


Exceptex.exe

Voor meer informatie over het downloaden van Microsoft-ondersteuningsbestanden, klikt u op het volgende artikelnummer het artikel in de Microsoft Knowledge Base:
119591Hoe Microsoft-ondersteuningsbestanden via Online Services downloaden
Microsoft heeft dit bestand op virussen. Microsoft gebruikt de meest huidige software voor virusdetectie die beschikbaar op de datum was dat het bestand is geboekt. Het bestand is opgeslagen op beveiligde servers die helpen onbevoegde wijzigingen aan het bestand verhinderen.

Meer informatie

Win32- en C++ Exception Handling samenvoegen

C++ Exception handling en Win32 Structured Exception Handling een andere syntaxis gebruiken om uitzonderingen.
    // C++ Exception Handler
    try
    {
        // Do something that may raise an exception
    }
    catch( <class name> <instance of class> )
    {
        // handle exception
    }

    // Win32 Structured Exception Handler
    __try
    {
        // Do something that may raise an exception
    }
    __except( expression )
    {
        // handle exception
    }
				
Het fundamentele verschil dat C++ exception handling wordt verwacht een exemplaar van een type dat de vangst Win32 gestructureerde uitzonderings afhandeling slechts drie niet-ondertekende ints vangsten.

U kunt echter beide C++ samenvoegen en Win32 uitzondering verwerken via de functie _set_se_translator(). Hierdoor een Win32-uitzondering worden doorgegeven aan de afhandelings functie van uw keuze, die Win32 uitzonderings gegevens laten teruglopen in een klasse en 'Gooi' als een C++ uitzondering. Dit gebeurt automatisch wanneer een Win32-uitzondering optreedt, en naadloos wordt weer gegeven aan het programma als een C++-uitzondering (Zie uitzondering verwerken Verschillen in de infoviewer 5. 0 VC). Dit wordt gedaan voor u automatisch als gebruik van de log boek macro's en verwante ondersteuning Log() functies.
    // Class for containing information on a Win32 Structured Exception
    class SEH_Exception {
    private:
        SEH_Exception() {}
        unsigned int m_uSECode;
    public:
        SEH_Exception(unsigned int uSECode) : m_uSECode(uSECode) {}
        ~SEH_Exception() {}
        unsigned int getSeHNumber() { return m_uSECode; }
    };

    // Handler function that passes on Win32 Exception information in the
    // C++ class SEH_Exception
    void MappingSEHtoCPPExceptions( unsigned int uExceptionCode,
                                                  _EXCEPTION_POINTERS* )
    {
        throw SEH_Exception( uExceptionCode );
    }

    // Initialize Exception Handling
    void LogEnable( ... )
    {
        // Set Win32 Exceptions to be handled as C++ typed exceptions
        _set_se_translator(MappingSEHtoCPPExceptions);

        ...
    }
				
In dit geval zou LogEnable worden eenmaal aangeroepen, vroeg in het programma uitvoering en Win32 uitzonderingen verhoogd kunnen worden gevangen met de syntaxis. Het EXCEPTEX voorbeeld demonstreert dit met behulp van de bovenstaande code.

Soorten C++ uitzonderingen

Er zijn diverse categorieën van C++ uitzonderingen die kunnen worden onderschept. MFC - gebaseerd programma:

  • Instanties van klassen zijn afgeleid van MFC CException
  • Instanties van een klasse die een Win32 Uitzondering
  • Instanties van een klasse-com_error die wordt gegenereerd door Visual C++ 5. 0 COM-ondersteuning beschikbaar via de instructie # import.
EXCEPTEX biedt een functie aangeroepen voor elk van deze LogException () overladen voor het specifieke type uitzondering wordt gevangen. In per geval een uitzondering genereert een exemplaar of een pointer van een bepaald type meestal een C++-klasse. Er zijn over-loaded versies van LogException voor elk C++ Exception bovengenoemde typen.

Hieronder volgt een voorbeeld van de verklaring voor de overbelaste LogException functie die een pointer vangsten met de MFC-CException-klasse.
    // Crack open and log details of different types of exceptions
    extern void LogException( CException    *e,
                              LPCSTR        lpszTimeStamp,
                              LPCSTR        lpszFile,
                              int           nLine        );
				
LogException houdt ook de bestands naam en regel nummer waar de uitzondering macro het laatst is gebruikt in de aanroepstack (indien gebruikt in combinatie met het hulp programma log boek macro).

Elk van deze helper functies barsten open de uitzondering en slaat de resultaten in een teken reeks matrix die u desgewenst kunt verwerken. Het de functie voor het dumpen van de inhoud van deze teken reeks matrix met de macro trace () is LogDisplay().

Helper macro's vereenvoudigen try/catch blokkeert

Rommelige na littering try/catch-blokken in uw code kunt krijgen een terwijl. Het is echter mogelijk te vereenvoudigen met uitzonderings blokken macro's. EXCEPTEX biedt drie macro's om dit proces te vereenvoudigen en elk biedt verschillende functies voor registratie/afhandeling van uitzonderingen. Elk van de macro's worden ook werken voor Visual C++ 4. x en Visual C++ 5. 0 zo geschreven zij moeten de versie van de compiler die u gebruikt controleren.

Hieronder vindt u de eenvoudigste van de macro's LOGQ (stille uitzonderings afhandeling met geen log boek registratie). Deze verwacht dat een Boole-variabele met de naam bRetVal in de code beschikbaar is. Deze moet worden voldaan zodat de macro kan leiden tot uitvoering van de code die kan verhogen een uitzondering, en wordt ingesteld op FALSE als een uitzondering wordt gegenereerd.
    #if _MSC_VER < 1100    // For version VC++ 4.2 or earlier

        #define LOGQ( f ) if( bRetVal == TRUE )                \ 
                          {                                    \ 
                             try                               \ 
                             {                                 \ 
                                 f;                            \ 
                             }                                 \ 
                             catch( CException *e )            \ 
                             {                                 \ 
                                bRetVal = FALSE;               \ 
                                 e->Delete();                  \ 
                             }                                 \ 
                             catch( SEH_Exception )            \ 
                             {                                 \ 
                                bRetVal = FALSE;               \ 
                             }                                 \ 
                             catch(...)                        \ 
                             {                                 \ 
                                bRetVal = FALSE;               \ 
                             }                                 \ 
                          }

    #else

        #define LOGQ( f ) if( bRetVal == TRUE )                \ 
                          {                                    \ 
                             try                               \ 
                             {                                 \ 
                                f;                             \ 
                             }                                 \ 
                             catch( CException *e )            \ 
                             {                                 \ 
                                bRetVal = FALSE;               \ 
                                e->Delete();                   \ 
                             }                                 \ 
                             catch( _com_error )               \ 
                             {                                 \ 
                                bRetVal = FALSE;               \ 
                              }                                \ 
                             catch( SEH_Exception )            \ 
                             {                                 \ 
                                bRetVal = FALSE;               \ 
                             }                                 \ 
                             catch(...)                        \ 
                             {                                 \ 
                                bRetVal = FALSE;               \ 
                             }                                 \ 
                          }

    #endif
				
De #ifdef _MSC_VER de definitie van de macro die moet worden beperkt specifiek voor Visual C++ 4. x of 5. 0. De versie 5. 0 bevat een vangst voor de nieuwe com_error uitzondering (gegenereerd door gemaakt op basis van code # import).

Zou u LOGQ zoals hieronder:
    int     i = 0;
    int     j;
    BOOL    bRetVal = TRUE;

    // This code is not safe
    j = 1 / i;        // Raises Win32 Divide By Zero exception

    // This code is safe
    LOGQ( j = 1 / i; )
				
Er zijn twee versies van de log boek macro's die door EXCEPTEX. De tweede macro log boek maakt gebruik van overbelaste LogException() helpers beschreven hierboven.
    #define LOGE( f ) try                               \ 
                      {                                 \ 
                          f;                            \ 
                      }                                 \ 
                      catch( CException *e )            \ 
                      {                                 \ 
                          LogException( e,              \ 
                                        __TIMESTAMP__,  \ 
                                        __FILE__,       \ 
                                        __LINE__      );\ 
                      }                                 \ 
                      ...
				
Met deze macro maakt geen gebruik van de vlag bRetVal. Wordt altijd de code ingekapseld door de macro uitvoeren, verhoogde Uitzonderingen afvangen en melden de inhoud ervan.

De uiteindelijke log boek macro geleverd door EXCEPTEX, LOGR, combineert LOGQ en LOGE. Wordt gecontroleerd als de code moet worden uitgevoerd en Meld elke uitzondering die wordt verhoogd.
    #define LOGR( f ) if( bRetVal == TRUE )                 \ 
                      {                                     \ 
                          try                               \ 
                          {                                 \ 
                              f;                            \ 
                          }                                 \ 
                          catch( CException *e )            \ 
                          {                                 \ 
                              LogException( e,              \ 
                                            __TIMESTAMP__,  \ 
                                            __FILE__,       \ 
                                            __LINE__      );\ 
                              bRetVal = FALSE;              \ 
                          }                                 \ 
                          ...
                        }
				

Andere handige functies

Het EXCEPTEX voorbeeld bevat drie meer functies om te helpen afhandeling van uitzonderingen:
LogDisplay()De inhoud van alle vastgelegde uitzonderingen uit via spoor macro's dumpen.

LogDisplay (...)De inhoud van alle vastgelegde uitzonderingen uit naar een exemplaar van dumpen CListBox.

LogSaveToFile (...)Inhoud van alle vastgelegde uitzonderingen uit om een bestand te dumpen.

LOG BOEK.H en log boek.CCP

LOG BOEK.H en log boek.CCP bevatten alle code in voor het verwerken van EXCEPTEX uitzonderingen. De rest van de steek proef is te tonen dat de macro's/functies gevonden in log boek.H en log boek.CCP. Deze twee bestanden kunnen eenvoudig worden toegevoegd aan een bestaande project en zijn geschreven in Visual C++ 4. x of 5. 0 onder compileren ANSI- en Unicode-bouwt. Met deze toevoegen # "log.h" naar de bestanden opnemen dat de macro LOGE of LOGR wordt gebruikt. Als u wilt kraken Win32 Gestructureerde uitzonderingen ook, moet u LogEnable eenmaal aan het begin van het programma.
   // One time initialization of data
    LogEnable(false);     // false to verbose mode
				
De log boek macro code die u wilt ophalen met uitzondering van toevoegen.
   ...
   LOGE(myFunction())
   ...
				
Houd er rekening mee dat het bestand en regel nummer vermeld zal de laatste LOG macro op de stack. Als myFunction () wordt aangeroepen myFun1() en myFun2(), zult u omloop van elke functieaanroep met een macro log boek voor de uitvoer wilt weer geven die belt de uitzondering in.

U mag niet altijd wilt gebruiken het log boek macro's of zelfs LogException() helpers zoals bedoeld. Ze zijn beide als aangeboden een gemak en alsook om te demonstreren uitgebreide exception handling en voor het registreren van de resultaten van eventuele uitzonderingen die zijn gevangen. Ze zijn niet beschikbaar als de end-all worden alle voor de afhandeling van uitzonderingen in elke productie-omgeving.

Problemen oplossen

De volgende code toont hoe de helper macro's gebruiken
    LOGQ( int i = 0; )
    LOGQ( int j = 1 / i; )    // Will this raise a divide by zero?
				
Deze code een compilatie fout gegenereerd als ik alleen in het bereik is gedefinieerd van de eerste LOGQ macro. Houd er rekening mee dat LOGQ uitgebreid:
>
    ...
    try
    {
        int i = 0;
    }
    ...

    ...
    try
    {
        int j = 1 / i;  // error C2065: 'i' : undeclared
    }
    ...
				

/ W4 en # import

Als u de vlag /W4 in Visual C++ en de instructie # import gebruikt, wordt u 8 waarschuwingen gegenereerd uit de include-bestanden die gebruikmaakt van # import worden weer gegeven.
comutil.h(905): waarschuwing C4310: cast constante waarde afgekapt
comutil.h(928): waarschuwing C4310: cast constante waarde afgekapt
comutil.h(1030): waarschuwing C4310: cast constante waarde afgekapt
comutil.h(1281): waarschuwing C4310: cast constante waarde afgekapt
comutil.h(1307): waarschuwing C4310: cast constante waarde afgekapt
comutil.h(1476): waarschuwing C4310: cast constante waarde afgekapt
Comdef.h(242): waarschuwing C4244: "terug": conversie van "int" op 'korte unsigned', mogelijk verlies van gegevens
Deze foutberichten kan worden genegeerd en doet geen afbreuk aan de code.

Voor meer informatie

Het onderwerp infoviewer VC + + 5. 0 biedt een goede Inleiding tot de verwerking van technieken:
Afhandeling van uitzonderingen: Veelgestelde vragen
MK:@ivt:vccore/F26/D2A/S31BE4.HTM

Exception Handling verschillen
MK:@ivt:vccore/F26/D2B/S4CC99.HTM
Het volgende artikel demonstreert technieken die kunnen worden gebruikt het EXCEPTEX voorbeeld voor het verwerken van uitzonderingen DAO SDK uitbreiden.
152695Onderschept en ontcijferd DAO SDK gebaseerde uitzonderingen
Een definitieve bron op de verwerking van Win32-uitzondering kan worden gevonden in:

"Geavanceerde Windows" Jeffrey Richter, ISBN 1-57231-548-2

Eigenschappen

Artikel ID: 167802 - Laatste beoordeling: woensdag 23 februari 2011 - Wijziging: 2.0
De informatie in dit artikel is van toepassing op:
  • Microsoft Visual C++ 4.2 Enterprise Edition
  • Microsoft Visual C++ 5.0 Enterprise Edition
  • Microsoft Visual C++ 5.0 Professional Edition
Trefwoorden: 
kbdownload kbdatabase kbfile kbsample kbmt KB167802 KbMtnl
Automatisch vertaald artikel
BELANGRIJK: Dit artikel is vertaald door de vertaalmachine software van Microsoft in plaats van door een professionele vertaler. Microsoft biedt u professioneel vertaalde artikelen en artikelen vertaald door de vertaalmachine, zodat u toegang heeft tot al onze knowledge base artikelen in uw eigen taal. Artikelen vertaald door de vertaalmachine zijn niet altijd perfect vertaald. Deze artikelen kunnen fouten bevatten in de vocabulaire, zinsopbouw en grammatica en kunnen lijken op hoe een anderstalige de taal spreekt en schrijft. Microsoft is niet verantwoordelijk voor onnauwkeurigheden, fouten en schade ontstaan door een incorrecte vertaling van de content of het gebruik ervan door onze klanten. Microsoft past continue de kwaliteit van de vertaalmachine software aan door deze te updaten.
De Engelstalige versie van dit artikel is de volgende:167802
Vrijwaring inhoud KB-artikelen over niet langer ondersteunde producten
Dit artikel heeft betrekking op producten waarvoor Microsoft geen ondersteuning meer biedt. Daarom wordt dit artikel alleen in de huidige vorm aangeboden en wordt het niet meer bijgewerkt.

Geef ons feedback

 

Contact us for more help

Contact us for more help
Connect with Answer Desk for expert help.
Get more support from smallbusiness.support.microsoft.com