std::map find fehler

Hallo!

ich benötige Hilfe bei einem Code, in dem ich die std::map routinen Verwende. Diese funktionieren seit Kurzem nicht mehr und ich finde den Fehler leider nicht. In dem Code verwalte ich Knoten, die ich nach ihrer ID finden möchte. Die Knoten sind über eine Klasse definiert, die ich in der std::map ablege. Der Code lautet:

template < typename NodeType > class BaseNLs
{
   public:									
   BaseNLs();
   NodeType* GetNodeOfGlobNr(int nGlobNr);
   ...
   protected:
   std::map< int, NodeType* > m_mapND;	
}

Hinzufügen von Punkten:

NodeType pNewNode = new NodeType(nGlobNr, coo); // int nGlobNr, coo: Koordinaten
 m_mapND[nGlobNr] = pNewNode;

Suchen der Punkte mittels:

std::map <int, NodeType* >::iterator iter;
 iter = m_mapND.find(NodeNr);

Die Funktion map.find() findet leider nie einen Eintrag. Zudem habe ich festgestellt, dass die Einträge in m_mapND nicht sortiert werden. - Kann mir jemand sagen woran dies liegen kann?

Besten Dank für die Hife!

SeppJ

Da werden Pointer sortiert, das ist dir klar, oder? Falls du das nicht möchtest, musst du eine passende Vertauschungsfunktion schreiben und angeben.

Und warum überhaupt über Pointer? Mag sein, dass du einen Grund hast, aber er wird nicht klar, da deine Klasse keine virtuellen Methoden hat.

pumuckl

dein "new NodeType" sollte ein NodeType* und nicht ein NodeType zurückgeben.
mit "m_mapND[nGlobNr] = pNewNode;" Handelst du dir evtl. Speicherlecks ein, wenn schon ein Eintrag für nGlobNr vorhanden war.

Zu deinem Problem: Anhand deines Codes kann ich jetzt nichts sehen. Du hast aber ganz offensichtlich nicht den originalcode gepostet (siehe 1), das hätte so nicht compiliert).

Liefere uns bitte mal den aufs Wesentliche reduzierten, compilierbaren Code, mit dem man den Fehler noch nachstellen kann.

pumuckl und SeppJ, vielen Dank für die schnellen Antworten.

Zu 1)

NodeType pNewNode = new NodeType(nGlobNr, coo);

war ein Tippfehler. Richtig lautet die Zeile:

NodeType *pNewNode = new NodeType(nGlobNr, coo);

Zu 2) Ich prüfe zunächst, ob der Eintrag schon vorhanden ist und füge ihn nur zu, wenn dies noch nicht der Fall ist. Zudem erhalte ich den gleichen Fehler, wenn ich die map.insert - Funktion verwende.

Ich stelle jetzt eine abgespeckte Version meines Codes zusammen und werden ihn posten, sobald ich damit fertig bin.

Thilo

krümelkacker

SeppJ schrieb:

Da werden Pointer sortiert, das ist dir klar, oder?

Der Schlüssel ist doch vom Typ int.

@Thilo: zu wenig Kontext gibt's hier.

Nochmals vielen Dank für die Antworten. Wie gewünscht, habe ich den orginalen Code etwas reduziert, um ihn vollständiger anzugeben. Auch mit diesem Ausschnitt kann ich den Fehler reproduzieren. Für Hinweise zum Fehler wäre ich Euch dankbar.

#include <vector>
#include <map>
#include <stdlib.h>
#include <iostream>

struct Node
{
	std::vector< double > _coo;
	int     _globNr;
};

class NLs
{
public:							
	NLs(){};						
	void addNode(int nGlobNr,  std::vector< double > *coo);
	Node* findNode(int nGlobNr);
protected:						
	std::map< int,  Node* > m_mapND;		
};

void NLs::addNode(int nGlobNr, std::vector< double > *coo)
{
	Node *newNode = NULL;
	std::map <int, Node*>::const_iterator iter;
	int tf(0);
	iter = this->m_mapND.find(nGlobNr);
	if(iter==m_mapND.end())		
	{
		newNode = new Node();
		for(int i=0; i<3; i++)
			newNode->_coo.push_back( (*coo)[i] );
		newNode->_globNr = nGlobNr;
		m_mapND.insert(std::pair< int, Node* >(nGlobNr,newNode) );		
	}	
}
Node* NLs::findNode(int NodeNr)
{
	std::map <int, Node* >::iterator iter;
	Node *fN;	

	iter = m_mapND.find(NodeNr);
	if(iter!=m_mapND.end()){
		fN = iter->second;
		return fN;
	}
	else{
		std::cout << " Knoten mit der globalen Nr " << NodeNr << " nicht gefunden " << std::endl;
		return NULL;
	}

}
int main()
{			
	NLs NodeList;
	std::vector< double > coo(3);
	coo[0] = 0.0;
	coo[1] = 1.3;
	coo[2] = 4.6;

	NodeList.addNode(1, &coo);
	NodeList.addNode(2, &coo);
	NodeList.addNode(3, &coo);
	NodeList.addNode(4, &coo);

	Node* fN = NodeList.findNode(4);
}

daddy_felix

Ich kann dein Problem nicht nachvollziehen. Habe den Code eben ausprobiert, da findet er einen Knoten.

@ daddy_felix: Das habe ich befürchtet. Kann es sein, dass der Fehler durch eine Compilereinstellung verursacht wird?

pumuckl

Thilo schrieb:

@ daddy_felix: Das habe ich befürchtet. Kann es sein, dass der Fehler durch eine Compilereinstellung verursacht wird?

Schwierig. Compilereinstellungen die ein gültiges Programm ungültig machen sind selten

Hast du mal ne Debug-Anzeige, was am Ende in der map steht?

In der Map stehen die Knoten. Diese sind jedoch nicht aufstreigend, sondern absteigend sortiert.

- m_mapND [4]
+ [0] (4,0x004b6388 {_coo=[3](0.00000000000000000,1.3000000000000000,4.5999999999999996) _globNr=4 }) std::pair<const int, Node *>
+ [1] (3,0x004b6240 {_coo=[3](0.00000000000000000,1.3000000000000000,4.5999999999999996) _globNr=3 }) std::pair<const int, Node *>
+ [2] (2,0x004b60f8 {_coo=[3](0.00000000000000000,1.3000000000000000,4.5999999999999996) _globNr=2 }) std::pair<const int, Node *>
+ [3] (1,0x004b2b00 {_coo=[3](0.00000000000000000,1.3000000000000000,4.5999999999999996) _globNr=1 }) std::pair<const int, Node *>

pumuckl

Thilo schrieb:

Diese sind jedoch nicht aufstreigend, sondern absteigend sortiert.

Das ist wurscht, solang das Suchen konsistent geschieht. Versuch mal mit dem Debugger durch map::find zu steppen und schau, was er da macht, und warum er den Knoten nicht findet.

krümelkacker

Ich kann da auch nichts erkennen, was falsch sein soll.

Trotzdem ein paar Kommentare:

Thilo schrieb:

class NLs
{
public:							
	NLs(){};						
	void addNode(int nGlobNr,  std::vector< double > *coo);
	Node* findNode(int nGlobNr);
protected:						
	std::map< int,  Node* > m_mapND;		
};

Das Semikolon hinter dem {} ist überflüssig. Selbst die ganze Zeile ist überflüssig.

Thilo schrieb:

void NLs::addNode(int nGlobNr, std::vector< double > *coo)

besser: std::vector<double> const& coo

Thilo schrieb:

{
	Node *newNode = NULL;
	std::map <int, Node*>::const_iterator iter;
	int tf(0);
	iter = this->m_mapND.find(nGlobNr);
	if(iter==m_mapND.end())		
	{
		newNode = new Node();
		for(int i=0; i<3; i++)
			newNode->_coo.push_back( (*coo)[i] );

Das geht auch einfacher:
newNode->_coo = *coo; // bzw "= coo;", falls coo eine Referenz ist

Thilo schrieb:

newNode->_globNr = nGlobNr;
		m_mapND.insert(std::pair< int, Node* >(nGlobNr,newNode) );

der value_type Deiner map ist pair<const int,Node*>.

Das Problem ist gelöst. Hatte nicht aufgepasst und eine Datei des Compilers geändert (functional.h).

Nochmals vielen Dank für die vielen und schnellen Antworten. Ich werde die Hinweise beachten!