Wie Erinnerung an eine Struktur mit Zeigern auf eine andere Struktur Befreien

Question

Ich habe zwei Strukturen

struct SimpleXY 
{ 
    double x; 
    double y; 

}; 

    struct SimpleXyLink 
    { 
      int num_xy; 
      SimpleXY *simpleXyList; 
    }; 

Ich frage mich, was der richtige Weg ist durch SimplyXyLink den Speicher halten zu befreien? Ich bin derzeit

void Free(SimpleXyLink *myList) 
{ 

    free(myList->simpleXyList); 
} 

Aber ich denke, das ist falsch, weil es nicht auf den Speicher innerhalb des Elements von simpleXyList entbindet.

Answer 1

Zuerst wird der Speicher, den Sie zu befreien sind nicht die SimpleXy * Link- * myList, nicht der Speicher innerhalb des simpleXyList (Sie befreien die durch diese gerade fein genannten Speicher).

Im Allgemeinen liegt es an Ihnen, einen Weg zu finden, den gesamten von Ihnen verwendeten Speicher freizugeben. Im Allgemeinen werden befreien Sie die genannten zu Daten vor der Struktur, die es, wie in verweist:

void FreeSimpleXy(SimpleXyLink *myList) { 
    free(myList->simpleXyList); 
    free(myList); 
} 

Note (nur C++) aber, dass, wenn Sie new verwendet zuzuteilen diese, Sie Muss Verwenden Sie stattdessen zum Löschen!

Wenn Sie C++ verwenden, gibt es auch mehr narrensichere Möglichkeiten. Erstens, Destruktoren. Sie könnten SimpleXyLink wie so ändern:

struct SimpleXyLink 
{ 
    int num_xy; 
    SimpleXY *simpleXyList; 
    ~SimpleXyLink() { 
     delete simpleXyList; 
    } 
    SimpleXyLink() { 
     simpleXyList = NULL; // run when object is created with new 
    } 
}; 

Jetzt können Sie nur delete someLink; tun und es wird das enthaltene simpleXyList automatisch freizugeben. jedoch, bedenken Sie, dass Sie darf nicht Verwendung malloc und free jetzt - statt new und delete verwenden:

SimpleXyLink *link = new SimpleXyLink; 
link->simpleXyList = new SimpleXYList; 
delete link; // all gone! 

Schließlich gibt es noch eine weitere fast magische Art und Weise, Dinge zu tun - intelligente Zeiger verwenden (auch Nur C++). Diese werden der nächsten Version von C++ hinzugefügt, aber Sie können sie heute verwenden, indem Sie boost library verwenden.

struct SimpleXyLink { 
    int num_xy; 
    boost::scoped_ptr<SimpleXyList> simpleXyList; // or shared_ptr 
}; 

Dies beseitigt die Notwendigkeit, einen Destruktor zu schreiben (Sie jedoch immer noch new und delete! Verwenden müssen), aber sie tragen auch mit ihnen andere Einschränkungen. Lesen Sie die Dokumentation, die ich verlinkt habe, sorgfältig durch, bevor Sie sie verwenden, und zögern Sie nicht, eine weitere Frage zu beantworten, wenn Sie sich noch nicht sicher sind.

Answer 2

Dies hängt ganz davon ab, wie Sie den Speicher zugewiesen haben. Das Freigeben von Speicher muss immer die Zuweisung widerspiegeln.

Das heißt, free ist fast sicher falsch in C++. Verwenden Sie new/delete anstelle von malloc/free.

Darüber hinaus scheint es, als ob Sie Speicher für mehrere Elemente Zuteilung sie (zumindest der Name …List dies impliziert), so dass Sie wahrscheinlich besser dran mit einer C++ Container-Struktur, wie vector oder list.

Answer 3

Wenn es C++ (Ich bin hier verwirrt, weil Sie kostenlos :-) verwenden)

struct SimpleXY 
{ 
    double x; 
    double y; 

}; 

struct SimpleXyLink 
{ 
    SimpleXyLink() : simpleXyList(new SimpleXY) { } 
    ~SimpleXyLink() { delete simpleXyList; } 

    int num_xy; 
    SimpleXY *simpleXyList; 
}; 

int main() 
{ 
    SimpleXyLink* pXYLink = new SimpleXyLink(); 

    delete pXYLink; 
}