Ich habe eine boost::unordered_map die Pointer auf Objekte speichert. Nach einer gewissen Zeit (3 Sekunden) möchte ich die Objekte löschen. Das mache ich mit folgender Methode

void BufferedTCPConnectionTracker::cleanUpMap( int64_t now, boost::unordered_map< long, ddos_packet*, boost::hash<long> >& map ) {

	std::vector<long> deletionMarkers;

	for( boost::unordered_map<long,ddos_packet*>::iterator it = map.begin(); it != map.end(); ++it ) 
		if( ( now - it->second->timestamp ) >= int64_t(3000000) /*3 Sekunden*/ || it->second->marker )
			deletionMarkers.push_back(it->first);

	for( unsigned int i = 0; i < deletionMarkers.size(); ++i) {
		delete map[deletionMarkers[i]];
		cout << map[deletionMarkers[i]]->getTCPSequenceNumber() << endl; 
		map.erase( deletionMarkers[i] );
	}
}

Das Problem bei der Sache ist, dass bei dieser Methode "eigentlich" alles sauber gelöscht werden sollte. Mir bereitet aber die Zeile

delete map[deletionMarkers[i]];

Kopfzerbrechen, denn eine Zeile darunter kann ich immer noch eine Methode von diesem Objekt in der Map aufrufen, ohne das ein Segfault auftritt. Wie kann das sein? Ist das Objekt etwa noch nicht gelöscht?

Dein großzügiges Benutzen von new und delete bereitet mir aber Sorge. Besonders wenn du selber zugibst, nicht besonders fit damit zu sein (sonst bräuchtest du nicht fragen). Ist das wirklich nötig? Und falls ja (was unwahrscheinlich ist): Wie wäre es mit etwas intelligenteren Pointern?

???

Du kannst Pointer dereferenzieren, auch wenn sie auf ein nicht existierendes Objekt zeigen. Das Verhalten ist dann undefiniert.

In der Praxis geschieht dann so etwas wie ein reinterpret_cast auf die Stelle an die der Pointer zeigt. Und da an der Stelle noch das alte Objekt liegt (da es noch nicht durch etwas anderes überschrieben wurde), kommt dabei sogar etwas sinnvolles raus, obwohl das Objekt offiziell ungültig ist. Ein delete setzt den Speicher schließlich nicht auf 0, sondern markiert nur in einer internen Tabelle den Speicherbereich als "wieder zum Schreiben verfügbar".

Dann musst du nachher selber nix mehr mit delete machen.

Ja, es ist sogar absolut nötig. Beantwortet aber nicht meine ursprüngliche Frage. Wieso bekomme ich keinen Segfault wenn ich auf ein gelöschtes Objekt zugreife?

Weil die Speicherverwaltung nicht so exakt arbeitet. Segfault heißt (auf x86-Architektur), dass du eine Speicherseite (=Segment) angefordert hast, die dir nicht gehört. Die Speicheradresse auf die dein Pointer verweist gehört deinem Programm aber noch. delete gibt freigegebenen Speicher in der Regel nicht an das Betreibssystem zurück sondern behält ihn auf Vorrat um ihn beim nächsten new erneut benutzen zu können.

Das ist wie gesagt alles undefiniert, aber so läuft es in der Praxis auf den gängigen Compilern/Betriebssystemen.

HändyÄndy schrieb:

Tja, da haben wir wohl gleichzeitig einen Beitrag geschrieben und Du warst wohle einen Tick schneller :). Danke für die Antwort.

Hehe, du jetzt auch . Aber doppelte Antwort hält besser .

Und, wow, ich hab auf boost::shared_ptr umgestellt und es funktioniert. top sagt mir jedenfalls, dass der Speicherverbrauch nach einer gewissen Zeit defacto konstant bleibt. Super Tip!

Nimm shared_ptr , wenn du tatsächlich geteilte Besitzverhältnisse hast.