Frage zu einer map

Ollow_AM

Hallo Community,

ich erstelle eine map mit (string, eigeneKlasse). Im schriftlichen ausgedrückt:
Ich lege werte in die Map mit dem Schlüsseln (B,C,D,E,F);

Später hole ich mir den const String-Schlüssel von 'B' ab und ändere dessen Inhalt z.B. auf 'X'.

Was zu dem ergebnis führt, das der Schlüsselwert in 'B' geändert wird, ich finde den Wert allerdings immernoch unter dem Schlüssel 'B' und nicht unter 'X'.

Soweit habe ich das schon getestet, bzw es ist klar das es nicht funktionieren kann ohne das die Sortierung 'aktuallisiert' wird.

Aber wollte es doch mal posten, evtl gibt es ja nen Trick oder doch einen Funktion die in der Liste die Key neu aktuallisiert, also eine Änderung der Sortierung ausführt.

Besten Dank schon mal für Anregungen, ich poste jetzt mal noch den Code:

// theClass - .h Datei

#ifndef __theClass__
#define __theClass__

// Header
#include <wx/wx.h>

class theClass
{
protected:
	wxString inhalt;
	const wxString* sort;

public:
	// ctor
	theClass();
	theClass(const wxString& newInhalt);

	// dtor
	~theClass();

	// Get Inhalt
	wxString getInhalt() const;

	// Zeiger auf Sort Get()
	const wxString* GetSortPointer() const;

	// SortSet
	void SortSet(const wxString* newSort);

};
#endif // __theClass__

// theClass - .cpp Datei

// eigener Header
#include "theClass.h"

// Header aus Header
#include <wx/wx.h>

// ctor
theClass::theClass()
:inhalt(wxEmptyString)
,sort(0)
{
}
theClass::theClass( const wxString& newInhalt)
:inhalt(newInhalt)
,sort(0)
{
}

// dtor
theClass::~theClass()
{
}

// Get Inhalt
wxString theClass::getInhalt() const
{
	return inhalt;
}

// Zeiger auf Sort Get()
const wxString* theClass::GetSortPointer() const
{
	return sort;
}

// SortSet
void theClass::SortSet(const wxString* newSort)
{
	sort = newSort;
}

// basic_frame - .cpp

// eigener header
#include "basic_frame.h"

// Header aus Header
#include <wx/wx.h>
#include <wx/frame.h>

// weitere Header
#include <map>
#include "theClass.h"

typedef std::map<wxString, theClass> mapStore;

BasicFrame::BasicFrame(const wxString &title, const int &xpos, const int &ypos, const int &width, const int &hight)
:wxFrame( (wxFrame *)0, -1, title, wxPoint(xpos,ypos), wxSize(width,hight) )
{
	panel = new wxPanel(this);

	mapStore t;

	// Fünf Objecte
	theClass obj1(_T("Text of 1-A"));
	theClass obj2(_T("Text of 2-B"));
	theClass obj3(_T("Text of 3-C"));
	theClass obj4(_T("Text of 4-D"));
	theClass obj5(_T("Text of 5-E"));

	// In die Liste
	t[_T("B")] = obj1;
	t[_T("C")] = obj2;
	t[_T("D")] = obj3;
	t[_T("E")] = obj4;
	t[_T("F")] = obj5;

	// Zeiger setzen
	for (mapStore::iterator it = t.begin(); it!=t.end(); it++)
	{
		it->second.SortSet(&it->first);
	}

	// Element 1 Holen
	mapStore::iterator it = t.begin();

	// const abholen
	const wxString* b = it->second.GetSortPointer();

	// const wegcaste
	wxString* b1 = const_cast<wxString*>(b);

	// X an B zuweisen
	*b1 = _T("X");

	// <--- hier müsste ich bei der map einen refresh ausführen // falls es sowas gibt

	//Liste neu sortieren
	it = t.find(_T("X"));

	if (it != t.end())
	{
		wxMessageBox(it->second.getInhalt());
	}
	else
	{
		wxMessageBox(_T("Not Found"));
	}

	bool allDone = true;
	allDone;
}

BasicFrame::~BasicFrame()
{
}

Tachyon

Du willst keine std::map, sondern ein std::set. Dabei ist der Wert gleich dem Schlüssel. Ein Update läuft dann so: Alten werden holen -> Alten Wert aus set löschen -> Alten Wert ändern -> geänderten Wert wieder ins set packen.
Was soll die Sache mit dem const_cast ?

Ollow_AM

Hallo, ich hole mir ja in

// const abholen
const wxString* b = it->second.GetSortPointer();

einen Zeiger auf den (wxString) Key ab. Um diesen Key zu ändern muss ich ja const wegcasten.

Alten Wert holen -> Alten Wert aus set löschen -> Alten Wert ändern -> geänderten Wert wieder ins set packen.

Hmm, eben das wollte ich umgehen. Indem ich den Key-Wert direkt ausändere und anschließend einen 'Refresh' der Liste starte in dem er quasi neu ordnet.

Gruß

Braunstein

Ollow_AM schrieb:

Hmm, eben das wollte ich umgehen. Indem ich den Key-Wert direkt ausändere und anschließend einen 'Refresh' der Liste starte in dem er quasi neu ordnet.

Das geht eben nicht mit der normalen map. Wenn du den Key ändern könntest wäre die map ja zwischenzeitlich in einem ungeordneten Zustand. Das soll vermieden werden.

Ollow_AM

Jap das ist genau das was ich vermutet habe. Aber evtl hätte es ja doch einen Kniff gegeben der es mir erlaubt der map quasi zu sagen, 'ordne dich neu'.

Vielen Dank und fröhliches proggen....

Braunstein

Du kannst dir ja deine eigene map schreiben.

Tachyon

Ollow_AM schrieb:

Jap das ist genau das was ich vermutet habe. Aber evtl hätte es ja doch einen Kniff gegeben der es mir erlaubt der map quasi zu sagen, 'ordne dich neu'.

Vielen Dank und fröhliches proggen....

Schreib Dir einfach eine freie Funktion, welche das für Dich macht, irgendwie so: void reorder(std::set<theClass> & container, wxString const & oldKey, wxString const & newKey) . Da drin machst Du dann das tauschen von neuem und alten Wert. Eine reorder -Funktion von std::set/std::map würde es auch nicht anders machen können.

Ollow_AM schrieb:

[...]
// const abholen
const wxString* b = it->second.GetSortPointer();
einen Zeiger auf den (wxString) Key ab. Um diesen Key zu ändern muss ich ja const wegcasten.
[...]

Dann mache doch b gar nicht erst const. Wenn der Rückgabewert von GetSortPointer() schon const -qualifiziert ist, dann ist es eh extrem unsauber.

Eisflamme

Ollow_AM schrieb:

Hallo, ich hole mir ja in
// const abholen
const wxString* b = it->second.GetSortPointer();
einen Zeiger auf den (wxString) Key ab. Um diesen Key zu ändern muss ich ja const wegcasten.

Alten Wert holen -> Alten Wert aus set löschen -> Alten Wert ändern -> geänderten Wert wieder ins set packen.

Hmm, eben das wollte ich umgehen. Indem ich den Key-Wert direkt ausändere und anschließend einen 'Refresh' der Liste starte in dem er quasi neu ordnet.

Gruß

Das neu sortieren ist definitiv langsamer als die paar Schritte, auch wenn du eine Zeile mehr schreiben musst.

Ollow_AM

@Eisflamme -

Ja, hmm denke mal weil er durch den Schlüssel direkt auf die Position zugreift diese löscht und dann wenn er das neue Object reinschiebt nur bis zu der Position durchgehen muss wo das neue Element eingefügt wird.

Und bei einem 'Refresh' müsste er vermutlich die gesamte Liste durchgehen, und damit eigentliches jedes Element 'anfassen'.

Thx...