Frage beim verhalten von delete

Hallo,
Ich schreibe gerade eine verlinkte Liste mit Klassen.

linkedList::linkedList()
{
	startPtr = new Startnode;
};

linkedList::~linkedList()
{
	delete startPtr;
};

class Startnode : public Node
{
private:
	Node* next;
public:
	Startnode();
	~Startnode(){}
	void print();
	Node* insert(Computer* Data);
};

Startnode::Startnode()
{
	next = new Endnode;
}

Wenn startPtr wieder freigegeben wird, bleibt der reservierte Speicher für Endnode im ehemaligen startPtr bestehen, nur der Speicher für den Pointer wird gelöscht, d.h. auf der Adresse vom nicht mehr existenten next ist immer noch nicht freigegebener Speicher. Oder?

Müsste ich jetzt noch im Destruktor von Startnode folgendes schreiben?

Startnode()::~Startnode()
{
	delete next;
}

cooky451

Startnode? Endnode? Wtf? Wie wäre es mit node*? Abgesehen davon wird der Pointer selbst nirgends freigegeben, das geht gar nicht, der liegt auf dem Stack. delete gibt immer das frei, worauf der Pointer zeigt.

cooky451 schrieb:

Startnode? Endnode? Wtf? Wie wäre es mit node*? Abgesehen davon wird der Pointer selbst nirgends freigegeben, das geht gar nicht, der liegt auf dem Stack. delete gibt immer das frei, worauf der Pointer zeigt.

Hast du meine Frage richtig gelesen? Wenn ich einen Speicherbereich der auf dem Heap liegt freigebe, der einen Pointer auf ein weiteres Objekt im Heap hat, wird dann auch dieser Speicher gelöscht oder wird nur der Pointer gelöscht, da dort nicht delete verwendet wurde.

linkedList::linkedList()
{
    startPtr = new Startnode; //Objekt im Heap
};

linkedList::~linkedList()
{
    delete startPtr; //Freigeben von Objekt
};

class Startnode : public Node
{
private:
    Node* next; //Ein Pointer, der beim insert auf ein Objekt im Heap zeigt
public:
    Startnode();
    ~Startnode(){}
    void print();
    Node* insert(Computer* Data);
};

Startnode::Startnode()
{
    next = new Endnode; //Wird der Speicher freigegeben, obwohl ich im Destruktor kein delete habe, wenn Startnode im Heap ist? Da im Buch, dass ich lese kein Destruktor definiert wurde und dies mich verwirrt
}

Das meinte ich:

private:
    Node* next; //Ein Pointer, der nach dem Konstruktordurchlauf auf ein Objekt im Heap zeigt

Zu jedem new gehört ein delete und zu jedem new[] ein delete[].

Damit beantwortet sich die Frage von alleine. Wenn du also das Objekt mit new anlegst und das Objekt auch ein Objekt mit new anlegt, dann müssen beide mit delete freigegeben werden.

"Automatisch" passiert das nur, wenns im Destruktor abläuft. Denn delete ruft auch den Destruktor auf.

Danke für die Antwort. Wollte nur wirklich sicher gehen.