Um robuste C-Programm zu schreiben, wie vermeiden Sie zu viele verschiedene freie() Kombinationen?

Question

Zum Beispiel Ich brauche zwei Stücke von Speicher malloc, so:

void *a = malloc (1); 

if (!a) 
    return -1; 

void *b = malloc (1); 

if (!b) 
{ 
    free (a); 
    return -1; 
} 

Hinweis, wenn die zweite malloc fehlschlägt, muss ich „a“ zuerst befreien. Das Problem ist, kann dies sehr chaotisch sein, wenn es viele solcher malloc ist und die Fehlerprüfung des sind, es sei denn ich die berüchtigten „goto“ Klausel verwenden und sorgfältig die Reihenfolge der freien des arrangieren zusammen mit den Labels:

void *a = malloc (1); 

if (!a) 
    goto X; 

void *b = malloc (1); 

if (!b) 
    goto Y; 

return 0; //normal exit 

Y: 
    free (a); 
X: 
    return -1; 

Haben Sie eine bessere Lösung für diese Situation? Danke im Voraus.

Answer 1

Wir tun wie folgt aus:

void *a = NULL; 
void *b = NULL; 
void *c = NULL; 
a = malloc(1); 
if (!a) goto errorExit; 
b = malloc(1); 
if (!b) goto errorExit; 
c = malloc(1); 
if (!b) goto errorExit; 

return 0; 
errorExit: 
//free a null pointer is safe. 
free(a); 
free(b); 
free(c); 
return -1; 

Answer 2

Verwenden von goto ist meiner Meinung nach keine schlechte Sache. Die Verwendung zur Ressourcenbereinigung ist genau das Richtige.

Quellcode so berühmt wie der Linux-Kernel verwendet die Technik.

Verwenden Sie einfach nicht goto, um rückwärts zu gehen. Das führt zu Katastrophen und Verwirrung. Nur vorwärts springen ist meine Empfehlung.

Answer 3

Wie bereits erwähnt von Zan Lynx verwenden Sie die Anweisung goto.

Sie können auch größere Speicherbereiche für die weitere Verwendung zuweisen.

Oder Sie können Ihre Zeit investieren, um etwas wie memory pool zu entwickeln.

Answer 4

Oder dies tun.

void *a,*b; 
char * p = malloc(2); 
if (!p) return -1; 
a = p; 
b = p+1; 

Answer 5

denke ich OOP-Techniken Ihnen eine schöne und saubere Lösung für dieses Problem geben könnte:

typedef struct { 
    void *a; 
    void *b; 
} MyObj; 

void delete_MyObj(MyObj* obj) 
{ 
    if (obj) { 
     if (obj->a) 
      free(obj->a); 
     if (obj->b) 
      free(obj->b); 
     free(obj); 
    } 
} 

MyObj* new_MyObj() 
{ 
    MyObj* obj = (MyObj*)malloc(sizeof(MyObj)); 
    if (!obj) return NULL; 
    memset(obj, 0, sizeof(MyObj)); 

    obj->a = malloc(1); 
    obj->b = malloc(1); 

    if (!obj->a || !obj->b) { 
     delete_MyObj(obj); 
     return 0; 
    } 

    return obj; 
} 

int main() 
{ 
    MyObj* obj = new_MyObj(); 
    if (obj) { 
     /* use obj */ 
     delete_MyObj(obj); 
    } 
} 

Answer 6

Es gibt nichts wirklich falsch mit Ihrem goto Code IMO (ich würde ausführlichere Etiketten verwenden).

In diesem Fall erstellen die goto Anweisungen, die Sie geschrieben haben, genau die gleiche Struktur wie das Umkehren der if s.

Das heißt, ein bedingter Termin goto, die keinen Spielraum nicht verlassen hat genau die gleichen als if Anweisung ohne else. Der Unterschied ist, dass die gotopassiert nicht Bereich zu verlassen, während die if gezwungen ist, Umfang zu verlassen. Deshalb ist das if normalerweise einfacher zu lesen: Der Leser hat mehr Hinweise auf der Vorderseite.

void *a = malloc (1); 
if (a) { 
    void *b = malloc (1); 
    if (b) { 
     return 0; //normal exit 
    } 
    free(a); 
} 
return -1; 

Für ein paar Ebene dies in Ordnung ist, obwohl Sie „Pfeil-Code“ mit zu vielen Ebenen der Vertiefung bekommen zu weit gegangen. Das wird aus ganz anderen Gründen unlesbar.

Answer 7

Verwenden Sie einen Garbage Collector wie boehmgc.

Es funktioniert, es ist einfach zu bedienen, es gibt keine Verlangsamung im Gegensatz zu der allgemeinen Meinung.

https://en.wikipedia.org/wiki/Boehm_garbage_collector

http://www.hpl.hp.com/personal/Hans_Boehm/gc/