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!

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

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.

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

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

Der Schlüssel ist doch vom Typ int.

@Thilo: zu wenig Kontext gibt's hier.

#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: 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?

- 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 *>

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.

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*>.

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