Verwenden Sie Visual Studio-Ausnahme in C

Question

Ich verwende Sprache im Projekt. Irgendwann fiel mir auf, dass der Großteil des Codes überprüft wurde. Im Projekt der Rückgabetyp der Funktion bool. Da wir mit den Medien und wenn die Funktion lesen oder schreiben return false arbeiten wir Programm brechen müssen, Vor einiger Zeit habe ich gelernt, dass in Visual Studio verfügt über eine integrierte in Ausnahme (Verwendung von Visual Studio 2008)

__try 
__finally 

In der Projekt verwenden wir das Protokoll. Alle Funktionen verwenden Protokoll. Wir haben beschlossen, das Protokoll und die Ausnahme zu kombinieren. Verwenden Sie den Präprozessor

Anwendungsbeispiel. Funktion gibt den bool-Wert zurück

Bool_T Node_Insert(IN OUT Tree_T * tree, IN Text_T fullPath, ...) 
{ 
    Text_T itemName  = NULL; 
    int * delimiterPos = NULL; 

    try 
    { 
      // if tree is empty we should add ROOT_PATH 
      // 
     if(Tree_IsEmpty(IN *tree)) 
     { 
     if(failed Tree_CreateRoot(IN OUT *tree, IN datafield)) 
     { 
      LOG_ERROR("Node_Insert FAILURE --> Tree_CreateRoot failed"); 
      return_false; 
     } 
     } 

     if(Text_Length(IN fullPath) > 1) 
     { 
     ... 
     // Allocate memory for Text 
     // 
     item = Text_New(); 

     // Allocate for delimeterPos array 
     // 
     delimiterPos = NEW(n, sizeof(elem)); 
     ... 

     while(i < nDelimiter) 
     { 
      ... 
      ... 
      ... 
     } 

     } 
     else if (Text_Length(IN fullPath) == 1 ) 
     { 
     // we have already added ROOT 
     // 
     return_true; 

     }else{ 

     LOG_ERROR("Node_Insert FAILURE --> Path length is not correct"); 
     return_false; 
     } 
    } 

    // In the end we need free allocated memory 
    // 
    finally 
    { 
    Text_Delete(IN OUT &itemName); 
     free(delimiterPos); 
    } 
    // in end_try preprocessor we write log and return true or false 
    // 
    end_try; 
} 

Anwendungsbeispiel. Methode, die keinen Wert zurückgibt

void Ifo_ReadBufferHeader(IN Uint8_T * buffer, ... IN OUT Int32_T * position) 
{ 
    Text_T fullPath = NULL; 

    try 
    { 
    // getting buffer size 
    // 
    Uint32_T size = Buffer_GetSize(IN buffer); 

    // getting mode 
    // 
    Uint8_T writeMode = Buffer_GetWritingMode(IN buffer); 

    if(Ifo_IsAddMode(IN static_cast(DataIfoMode_T, writeMode))) 
    { 
     Uint32_T pos = 1 + Ifo_GetLabelLength() + 23; 

     // getting path length 
     // 
     fullPath = Text_New(IN "", IN mp); 
     Buffer_GetNameField(IN buffer, OUT &fullPath, IN OUT &pos); 

     *parentFolderPath = fullPath; 
     *position = pos; 
    } else if(Ifo_IsRenameMode(IN static_cast(DataIfoMode_T, writeMode)) 
      { 
       *position = 1 + Ifo_GetLabelLength() + 23; 
      } 

     *bufferSize = size; 
     *mode  = static_cast(DataIfoMode_T, writeMode); 

     // return_void preprocessor that use 
     // 
     return_void; 

    } 
    finally 
    { 
     // After run the main code you must free allocated memory 
     // 
     Text_Delete(IN OUT &fullPath); 
    } 
    end_try; 
} 

Meine Frage ist. Wie gestalte ich, was würde es einen Wert zurückgeben? Das heißt, die Funktion wird einen Wert zurückgeben, z. B. den Puffer-CRC-Rückgabewert als Wert berechnen. Wie mache ich das mit diesen Makros?

int GetCrcBuffer(IN Uint32_T buffer, IN Tree_T tree) 
{ 
    Text_T itemName = NULL; 
    int crc  = 0; 

    try 
    { 
     ... 
     ... 
     itemName = Text_New(); 

     if(crc != 12) 
     { 
     return_value(crc); // ???? return value of crc and delete text??? how??? 
     } 
     ... 
     ... 
    } 
    finally 
    { 
     Text_Delete(IN OUT itemName); 
    } 
    end_try; 
} 

Wie man es laufen lassen schließlich blockieren und Rückgabewert crc ?? Wie schreibe ich den Präprozessor return_value() ???

Answer 1

Ihr endgültiger Block löscht ordnungsgemäß itemname, so dass Sie sich nicht um diesen Teil kümmern müssen. Der einzige Trick ist, dass Ihr Rückgabewert nicht -1 sein kann (das heißt: -1 kann kein legitimer Rückgabewert sein), da dies einen Fehler in end_try signalisiert. Dann einfach wie mit raise(e), können Sie einen Parameter den Makro angeben:

#define return_value(v) ##__FUNCTION__##ReturnValue = (v);      \ 
         __leave 

Wenn Sie eine Funktion schreiben wollen, die nnon-Integral-Typen zurückgeben kann, können Sie diesen Trick tun können: hat die Funktion tatsächlich einen int zurückgeben Signalisierungs Erfolg/Misserfolg, und im Fall des Erfolgs, den eigentlichen „Rückgabewert“ (der nicht-integrale Typ eins) zurück über einen Zeiger Parameter übergeben:

#define return_value2(v) *ret_val=(v);           \ 
         ##__FUNCTION__##ReturnValue = 1;      \ 
         __leave 

int GetMyType(IN Uint32_T buffer, IN Tree_T tree, MyType* ret_val) 
{ 
    ... 
} 

Anmerkung: der Wert ret_val Punkte gelten nur wenn die Funktion nicht zurückgelaufen ist -1