Gestione degli errori in C con "check-log-return": perché non utilizzare una macro?

Prendi il seguente esempio, senza alcun errore di elaborazione, e il rientro appena usato qui per mostrare i diversi passaggi:

 FILE *fp = fopen("data.txt", "rb");          // step 1: acquire file resource
   Forest* forest = generate_forest(fp,...);    // step 2: allocate tree resource 
     Tree *tree = get_tree(forest, "SPAIN"...);   
     Element *element = malloc(sizeof(element));  // step 3: allocate new element
       element->value = MAGIC; 
       tree_add(tree, element);                 // suppose element is copied into the tree
     free (element);                          // end step 3 
     ...
   release_forest (forest);                 // end step 2 (forest takes care of its trees)
   ...
 fclose (fp);                             // end step 1

Qui può esserci un errore causato da ogni singola istruzione. A seconda del passaggio in cui si verifica l'errore, potrebbe essere necessario rilasciare alcune o alcune risorse in più.

Alternativa 1

L'uso della tua macro per registrare ed elaborare i diversi errori causerebbe solo perdite di risorse, restituendo whle non tutte le risorse sono state rilasciate.

Alternativa 2

Uso di alcune istruzioni condizionali annidate:

 FILE *fp = fopen("data.txt", "rb");          // step 1: acquire file resource
 if (fp) {                                    // go on for step 1
     Forest* forest = generate_forest(fp,...);    // step 2: allocate tree resource 
     if (forest) {                                // go on for step 2
        Tree *tree = get_tree(forest, "SPAIN"...);   
        ...
        release_forest (forest);                  // end step 2 (forest takes  
     } 
     else {
        errcode = logmyerror ("forest not properly loaded", ENOTFOUND);
     }
     fclose (fp);                             // end step 1
 }
 else {
     errcode = logmyerror ("file not found ", EOOPSAGAIN);
 }
 return errcode;   // final exit point 

Alternativa 3

Il goto ignoto (beh, ha alcuni vantaggi come vedrai), dove diverse etichette corrispondono a punti di uscita per i passaggi pertinenti:

 FILE *fp = fopen("data.txt", "rb");          // step 1: acquire file resource
 if (fp==NULL) {
     errcode = logmyerror ("file not found ", EOOPSAGAIN);
     goto out0; 
 }
 Forest* forest = generate_forest(fp,...);    // step 2: allocate tree resource 
 if (forest==NULL) { 
     errcode = logmyerror ("forest not properly loaded", ENOTFOUND);
     goto out1; 
 }  
 Tree *tree = get_tree(forest, "SPAIN"...);   
 ... 
out2: 
 release_forest (forest);                 // end step 2 (forest takes care of its trees)
   ...
out1: 
 fclose (fp);                             // end step 1

out0: 
 return errcode; 

Conclusione

Ovviamente, se non si dispone di un'allocazione di risorse multilivello, è possibile utilizzare perfettamente la macro. Ma temo che ci siano molte situazioni di vita reale in cui ciò non sarà sufficiente.

Nota che in C ++ non avresti bisogno di questo se usi RAII, i distruttori puliranno sempre le risorse ogni volta che torni.