Was passiert beim Einfuegen in eine Datenstrucktur

Fellhuhn

An sich ja, aber man sollte dennoch nicht schlurig sein und sowas immer gleich richtig machen. Ist ja auch nicht wirklich Arbeit.

l'abra d'or

Und irgendwann muss dein Destruktor DOCH noch mal wichtige Aufgaben erledigen - und du bist es gewohnt dass dein Speicher automatisch vom OS freigegeben wird und löschst deine Objekte immer noch nicht selbständig

Fellhuhn

Warum auf Klo gehen wenn die Windel so schön alles hält?

Fellhuhn schrieb:

Warum auf Klo gehen wenn die Windel so schön alles hält?

wie recht du doch hast

ich habe jetzt aber ein weiteres Problem, ich habe einen Iterator ueber eine HashMap

for(hash_map<int,Node*>::iterator it = allNodes.begin(); it != allNodes.end();it++) {
  cout << it->num << endl;
}

Er laeuft bis ganz ans Ende, gibt also noch die letzte Zahl aus und bricht dann einfach ab, ohne Fehlermeldung. Mein debugger sagt Segmentation fault also irgendwas mit ueber Speicherbereich gelesen?!

<terminated>gdb/mi (1/27/10 3:40 PM) (Exited. Signal 'SIGSEGV' received. Description: Segmentation fault.)

wie kann den sowas passieren also irgendwie ist it++ dann ueber dem Speicherbereich und nicht allNodes.end() oder kann es sein das es allNodes.end() nicht gibt ?

Fellhuhn

Weiß ja nicht wie der Rest deines Codes aussieht, man benutzt aber eigentlich ++it statt it++.

Hab ich mal probiert, aendert aber auch nichts. Das ist ja eh eine eigenstaendige Anweisung am Ende einer Iteration.

So sieht der Rest der Schleife aus, das einzige was ich mache sind Zuweisungen, ich loesche nichts und veraendere auch nichts was ich in der Schleife benutze.

for(hash_map<int,Node*>::iterator it = allNodes.begin(); it != allNodes.end();++it) {
		cout << it->first << " ";
		for(hash_map<int,Node*>::iterator it1 = it->second->cameFrom.begin(); it1 != it->second->cameFrom.end();++it1) {
			cout << it1->first << " ";
			if(it1->second->away == 0) {
				it1->second->away = it->second->away+1;
				it1->second->from = it->second;

				newAllNodes[it1->first] = it1->second;
			}
 		}
		cout << "ENDE" << endl;

	}
	cout << "ENDE ALL" << endl;

Ich habe gerade nochmal was ausprobiert, ich mache diese Berechnung in einer Methode also

hash_map<int,Node*> allNodes;

vonDateiEinlese(allNodes);

findWay(allNodes);

findWay(hash_map<int,Node*> allNodes) {
	hash_map<int,Node*> newAllNodes;

	for(hash_map<int,Node*>::iterator it = allNodes.begin(); it != allNodes.end();++it) {
		cout << it->first << " ";
		for(hash_map<int,Node*>::iterator it1 = it->second->cameFrom.begin(); it1 != it->second->cameFrom.end();++it1) {
			cout << it1->first << " ";
			if(it1->second->away == 0) {
				it1->second->away = it->second->away+1;
				it1->second->from = it->second;

				newAllNodes[it1->first] = it1->second;
			}
 		}
		cout << "ENDE" << endl;

	}
	cout << "ENDE ALL" << endl;
}

Wenn ich die Berechnung die ich eigentlich in der Methode mache, gleich ohne Methode mache funktioniert es, habe ich da jetzt schon wieder was mit dem Uebergeben von Objekten falsch gemacht ?

Sebastian Pizer

xasew schrieb:

for(hash_map<int,Node*>::iterator it = allNodes.begin(); it != allNodes.end();it++) {
  cout << it->num << endl;
}
Er laeuft bis ganz ans Ende, gibt also noch die letzte Zahl aus und bricht dann einfach ab, ohne Fehlermeldung. Mein debugger sagt Segmentation fault also irgendwas mit ueber Speicherbereich gelesen?!
<terminated>gdb/mi (1/27/10 3:40 PM) (Exited. Signal 'SIGSEGV' received. Description: Segmentation fault.)
wie kann den sowas passieren also irgendwie ist it++ dann ueber dem Speicherbereich und nicht allNodes.end() oder kann es sein das es allNodes.end() nicht gibt ?

Nein. Viel wahrscheinlicher ist, dass Du ungültige Zeiger (oder Nullzeiger) in der map hast, die Du nicht dereferenzieren darfst, was Du aber mit "it->num" tust.

xaer schrieb:

findWay(hash_map<int,Node*> allNodes) {

Dir ist klar, dass allNodes hier eine lokale Kopie der Argument-Map ist, ja? Und dann zeigen die Elemente der Kopie auch noch auf dieselben Knoten-Objekte (sharing), die Du in der Funktion veränderst.

+-Node--+       +-Node--+
         | daten |       | daten |
         +-------+       +-------+
           A   A           A   A
           |   |           |    \_____________________________
           |    \__________|__________________                \
           |               |                  \                |
+-map------+---------------+-----+  +-map------+---------------+-----+
|          |               |     |  |          |               |     |
| +-pair-------+  +-pair-------+ |  | +-pair-------+  +-pair-------+ |
| | int, Node* |  | int, Node* | |  | | int, Node* |  | int, Node* | |
| +------------+  +------------+ |  | +------------+  +------------+ |
|                                |  |                                |
+--------------------------------+  +--------------------------------+
      (Argument von findWay)            (lokale Kopie in findWay)

Da kriegt man ja ganz schnell 'nen Knoten im Kopf. Ich muss gestehen, ich verstehe die Funktion findWay nicht. Vielleicht muss man dazu aber auch die Definition von Node kennen.

Ja, das ist auch ein bischen gekuerzt weil die Methode 2 Seiten lang ist.

Ich habe aber den Fehler gefunden.

Ich hatte ein

if(allNodes[end]) {

}

zum ueberpruefen ob der Endknoten enthalten ist benutzt, das Problem ist aber das die HashMap dann falls "end" nicht enthalten ist fuer den Key einen NullPointer anlegt und diesen dann zurueck gibt.
Der zerballert mir natuerlich dann auch die Iteration, das tragische ist aber das es ja manchmal funktioniert, naemlich immer dann wenn der Endknoten wirklich drin war das hat die Fehlersuche sehr erschwert...

Also waere es hier sinnvoller mit Pointern zu arbeiten ? gerade wenn es auf die Geschwindigkeit ankommt oder ?

Sebastian Pizer

defaef schrieb:

Also waere es hier sinnvoller mit Pointern zu arbeiten ? gerade wenn es auf die Geschwindigkeit ankommt oder ?

Es wäre sinnvoll, eine vernünftige Datenstruktur anzulegen und die auch soweit zu kapseln, dass man als Nutzer nicht viel falsch machen kann. Zum Bleistift einen "Graph"-Typen anlegen, der entweder nicht kopierbar ist, oder sich "regulär" verhält (--> "tiefe Kopie" wie es std::list, std::map etc auch machen).

Vielleicht kannst Du Dir von den Abstraktionen aus BGL etwas abgucken oder sogar einfach BGL benutzen.