Konkret würde ich gern von einem Coordinate-Objekt (also nur x- und y-Position) auf Spielfeldobjekte abbilden (weil bei meinem Spiel auf einem Feld mehrere Sachen stehen können).

Jetzt habe ich aber an zwei Stellen das Problem, daß es mehrere unterschiedliche Objekte sein können, die ich in diese Multimap an einer Koordinate packen will, d.h. einerseits ist meine Frage ob ich in eine add_item Funktion mit einem generischen Objekt Parameter deklarieren kann, also z.b.

add_item(Object new_Object, int x_pos, int y_pos)

bzw. wie ich das sonst machen kann (mir würde da sonst nur das Überladen der add-item Funktion für jedes mögliche Objekt einzeln einfallen),

und andererseits kommt natürlich die Frage auf, wie ich die multimap deklarieren muss, also ob es sowas wie

multimap<Coordinate, Object>

gibt.

class Base
{
};

class A : public Base
{
};

class B : public Base
{
};

class Coordinate
{
  Coordinate(int x, int y);
};

typedef std::multimap< Coordinate, Base* > Map;
typedef Map::value_type MapType;

mmap.insert(MapType(Coordinate(1,2), new A()));
mmap.insert(MapType(Coordinate(1,2), new B()));
mmap.insert(MapType(Coordinate(2,4), new B()));

Beim Löschen eines Objektes aus der Multimap mußt du dann aber noch das eigentliche Objekt von Hand deleten (am besten du schreibst dir dafür dann eine eigene Funktion).

Ich hoffe du kennst dich mit Vererbung und virtuellen Methoden aus, ansonsten stöbere mal ein bißchen danach.

Edit: Klammerfehler beseitigt

Ich habe aber noch drei Fragen, denn erstens wüsste ich gern, was folgende Zeile in deinem Code machen soll:

typedef Map::value_type MapType;

Edit: Habs selber rausgefunden..

Dann habe ich noch das Problem, daß ich nicht verstehe, was ich machen soll, wenn ich ein Objekt auf einen anderen Key "umkopieren" will.
Muss ich mir dazu das Objekt aus der Multimap holen und dann an der neuen Stelle ein neues Objekt (also mit den Werten des alten) mit new() anlegen?

Und schlussendlich, kannst du das mit dem deleten wenigstens etwas genauer erklären? In C++ kann man ein Objekt ja über einen Destruktor oder über delete() löschen, was davon muss ich in diesem Fall nehmen?

Leider sind meine C++ Fähigkeiten ein wenig begrenzt, und Lektüre über Vererbung und virtuelle Methoden hat mir keine Erleuchtung bei dieser Frage gebracht.

Achja und nochwas:
Sind Hash-Multimaps besser?
Und wenn ja, sind die in der STL drin und können ohne weiteres benutzt werden? In der Doku zur STL stand was davon, daß die immernoch nicht im C++ Standart drin sind und man selber eine Hashfunktion schreiben müsste, was für mich als Anfänger dann doch eher schlecht wäre...

zu 1.
Hast du ja anscheinend jetzt verstanden:
der Typedef dient nur dazu, nicht so viel tippen zu müssen...

zu 2.
Wenn du ein Objekt kopieren willst, dann mußt du das neue Objekt wieder mit new erzeugen (am besten dafür dann einen Copy-Konstruktor verwenden).
Wenn du ein Objekt einfach an eine andere Koordinate verschieben willst, dann brauchst du das Objekt nicht nochmal neu erzeugen (da es ja schon existiert).
Du mußt es nur an der alten Koordinate löschen (s. 3) und an der neuen Koordinate einfügen.

zu 3.
wenn ein Objekt mit 'new'erzeugt wurde, muß es auch irgendwo wieder mit 'delete' gelöscht werden (dieser ruft dann implizit den Destruktor der Klasse auf).
Wenn du ein Objekt aus der Multimap komplett löschen willst, dann mußt du es nicht nur aus der Multimap löschen (da dort nur der Zeiger vorhanden ist), sondern auch noch das eigentliche Objekt deleten.
Beispiel:

Map::iterator it = ...; // Iterator auf das zu löschende Element
delete *it;
map.erase(it);

Um an die Elemente einer Multimap zu kommen, schau dir mal die Methoden lower_range, upper_range und equal_range an.

zu 4. (obwohl du ja eigentlich nur 3 Fragen hattest, aber erste hast du ja selbst beantwortet)
Je nach STL-Implementierung gibt es auch Hash-(Multi)Maps, aber diese brauchst du erst zu verwenden, wenn die Performance der normalen Multimaps zu gering ist (d.h. wenn du einige Tausend oder mehr Objekte hast).
Im kommenden C++ Standard soll es dann sogenannte "unordered maps" geben, welche den Hash-Maps entsprechen.

Evtl. gibt es aber noch bessere Datentypen für dein Problem als die Multimap.
Wenn das Spielbrett eine geringe Zahl an Positionen hat, würde ich eher ein Array (vector) verwenden und je Position eine Liste von Objekten:

std::list<Base*> fields[MaxX][MaxY]; // alternativ auch std::vector

So ich hoffe, das hilft dir weiter...
Ich gehe jetzt ins Bett und evtl. schaue ich morgen noch mal hier rein -)

Deine Idee mit Array/Vector/Liste hatte ich auch schon, aber mein Spielfeld(ich mache ein Weltraum-Strategiespiel) hat definitiv viel zu viele Felder (ich mag es bei solchen Spielen, wenn der Maßstab riesig ist), als daß ich mir ein Array oder Vector leisten wollte. Ausserdem sind ja die meisten Felder eh leerer Weltraum, deswegen finde ich ne Multimap schon recht angemessen.

Oder irre ich mich da? Wie gesagt, ich bin leider noch recht "wackelig" im Programmiergeschäft, und wenn du meinst, es gibt eine effizientere Methode, dann werd ich die sicher ausprobieren.

Hier der Code so far:

#ifndef GALAXYMAP_HPP
#define GALAXYMAP_HPP

#include "Stellarobject.hpp"
#include "Starsystem.hpp"
#include "Coordinate.hpp"

#include <map>
#include <list>

class Galaxymap
{
	public:
		void add_item(Starsystem new_starsystem, int new_x_pos, int new_y_pos);
		void remove_item(Stellarobject curr_object, int x_pos, int y_pos);

	private:

		int x_size;
		int y_size;

		typedef map<Coordinate, list<Stellarobject*> > Galaxy_map;
		typedef Galaxy_map::value_type map_ype; 
};
#endif

#include "Galaxymap.hpp"

void Galaxymap::add_item(Starsystem cur_starsystem, int new_x_pos, int new_y_pos)
{
	//empty field in map?
	if(Galaxy_map.find(Coordinate(new_x_pos,new_y_pos)) == Galaxy_map.end())
	{
		//yes, so a new list has to be created and the new item has to be put in it
		list<Stellarobject*> new_list;
		new_list.push_back(new Starsystem(cur_starsystem));
		Galaxy_map.insert(map_type(Coordinate(new_x_pos,new_y_pos), new list<Stellarobject*>(new_list)));
	}
	else
	{
		//no, the item just has to be put into the existing list
		list<Stellarobject*> existing_list = Galaxy_map.find(Coordinate(new_x_pos, new_y_pos));
		existing_list.push_back(new Starsystem(cur_starsystem));
		Galaxy_map.insert(map_type(Coordinate(new_x_pos,new_y_pos), new list<Stellarobject*>(existing_list)));
	}
}

void Galaxymap::remove_item(Stellarobject curr_object, int x_pos, int y_pos)
{
	//Is there a list at the coordinates?
	if(Galaxy_map.get(Coordinate(x_pos,y_pos)) == NULL)
	{
		//No, there is no list which means that there is nothing at all
		cout << "Failed to find object at position" << x_pos << " " << y_pos << "(Map empty)" << endl;
	}
	else
	{
		//There is a list, so we have to search it for the object
		list<Stellarobject*> temp_list = Galaxy_map.get(Coordinate(x_pos, y_pos));

		list<Stellarobject*>:: iterator it;

		bool delete_success = false;

		for (it = temp_list.begin(); it != temp_list.end(); ++it)
		{
			if(it == curr_object)
			{
				delete *it;
				temp_list.erase(it);
				delete_success = true;
			}
		}
		if(!delete_success)
		{
			cout << "Object wasn´t in the list" << endl;
		}
	}
}

Dazu habe ich jetzt wieder einige Fragen:

1. Mein Compiler meint dazu:

Galaxymap.cpp:6: error: expected primary-expression before '.' token

und bezieht sich immerwieder damit auf Galaxy_map. Ist da was mit der typedef schiefgelaufen?
Passend dazu kommt noch:

Galaxymap.cpp:11: error: `map_type' undeclared (first use this function)

Und dann würde ich gern wissen, wie ich das hier richtig schreiben muss, weil es nur so ne Art placeholder ist, damit ihr versteht, was das mal werden soll

if(it == curr_object)

Ich will damit erreichen, daß das if ausgeführt wird wenn der iterator auf dem objekt steht, das ich suche...

Sceletor schrieb:

[cpp]
#ifndef GALAXYMAP_HPP
#define GALAXYMAP_HPP

#include "Stellarobject.hpp"
#include "Starsystem.hpp"
#include "Coordinate.hpp"

#include <map>
#include <list>

class Galaxymap
{
public:
void add_item(Starsystem new_starsystem, int new_x_pos, int new_y_pos);
void remove_item(Stellarobject curr_object, int x_pos, int y_pos);

Wenn du Zeiger auf Stellarobject in deinen Listen speicherst, sollte add_item evtl auch einen Zeiger oder eine Referenz auf ein solches uebernehmen, sonst musst du spaeter noch ein add_item(star_ship, int, int) und ein add_item(asteroid, int, int) usw. dazuschreiben. Ich wuerde einen Zeiger empfehlen, da sich der Aufrufer ja selbst um die Speicherverwaltung kuemmern muss und eine uebergabe per Referenz meist impliziert, dass das Objekt kopiert wird und der Container die Speicherverwaltung uebernimmt.
Bei remove_item reciht auch eine Referenz oder ein Zeiger, es ist unnoetig da das Objekt zu kopieren (die Kopie querde in den meisten Faellen auch den Vergleihcsoperator fuer die Suche fehlschlagen lassen)

private:

int x_size;
int y_size;

typedef map<Coordinate, list<Stellarobject*> > Galaxy_map;
typedef Galaxy_map::value_type map_ype; //TIPPFEHLER!!!
};
#endif
[/cpp]

#include "Galaxymap.hpp"

void Galaxymap::add_item(Starsystem cur_starsystem, int new_x_pos, int new_y_pos)
{
	//empty field in map?
	if(Galaxy_map.find(Coordinate(new_x_pos,new_y_pos)) == Galaxy_map.end())
	{
		//yes, so a new list has to be created and the new item has to be put in it
		list<Stellarobject*> new_list;
		new_list.push_back(new Starsystem(cur_starsystem));

Wenn du hier tatsaechlich selbst die Speicherverwaltung in die Hand nehmen willst, ok... aber dann reicht immernoch eine Referenz als parameter, und du musst den ganzen Mist fuer andere stellarobjects nochmal schreiben (evtl. template)

Galaxy_map.insert(map_type(Coordinate(new_x_pos,new_y_pos), new list<Stellarobject*>(new_list)));

statt map_type geht auch atd::make_pair(), und da du eine map<Coordinate, list> hast, sollte da hinten kein new stehen.

}
	else
	{
		//no, the item just has to be put into the existing list
		list<Stellarobject*> existing_list = Galaxy_map.find(Coordinate(new_x_pos, new_y_pos));
		existing_list.push_back(new Starsystem(cur_starsystem));

STOP! Du kopierst hier die Liste die du in deiner Map gefunden hast und packst das Neue Objekt in die Kopie, die nach der Funktion wieder geloescht wird. => Referenz auf die gefundene Liste benutzen.

Galaxy_map.insert(map_type(Coordinate(new_x_pos,new_y_pos), new list<Stellarobject*>(existing_list)));

letzteres kann dann wegfallen. Du versuchst hier naemlich eine Liste einzufuegen an eine Stelle, wo schon etwas war, das Einfuegen schlaegt daher fehl.

}
}

void Galaxymap::remove_item(Stellarobject curr_object, int x_pos, int y_pos)
{
	//Is there a list at the coordinates?
	if(Galaxy_map.get(Coordinate(x_pos,y_pos)) == NULL)

Das funktioniert so nicht. Wenn an den Koordinaten nix ist, gibts auch keine Liste. Ausserdem handelst du mit einer map<Coordinate, List> und nicht mit einer map von pointern. Versuchs mit

/*iterator*/ pos = Galaxy_map.find(Coordinate();
if (pos == Galaxy_map.end()) //...

im else-Zweig dann ueber den iterator weiterarbeiten

{
		//No, there is no list which means that there is nothing at all
		cout << "Failed to find object at position" << x_pos << " " << y_pos << "(Map empty)" << endl;
	}
	else
	{
		//There is a list, so we have to search it for the object
		list<Stellarobject*> temp_list = Galaxy_map.get(Coordinate(x_pos, y_pos));

ueber den iterator von vorhin einfach auf die Liste zugreifen udn nicht unnoetig kopieren.

list<Stellarobject*>:: iterator it;

		bool delete_success = false;

		for (it = temp_list.begin(); it != temp_list.end(); ++it)
		{
			if(it == curr_object)
			{
				delete *it;
				temp_list.erase(it);
				delete_success = true;
			}
		}

versuchs mal mit std::find, das liefert dir auch gleich den list::iterator, fuer den du dann erase() aufrufen kannst

if(!delete_success)
		{
			cout << "Object wasn´t in the list" << endl;
		}
	}
}

Dazu habe ich jetzt wieder einige Fragen:

1. Mein Compiler meint dazu:

Galaxymap.cpp:6: error: expected primary-expression before '.' token

Welches ist Zeile 6 bei dir?

und bezieht sich immerwieder damit auf Galaxy_map. Ist da was mit der typedef schiefgelaufen?
Passend dazu kommt noch:

Galaxymap.cpp:11: error: `map_type' undeclared (first use this function)

Da hast du n tippfehler in der typedef

Und dann würde ich gern wissen, wie ich das hier richtig schreiben muss, weil es nur so ne Art placeholder ist, damit ihr versteht, was das mal werden soll

if(it == curr_object)

siehe oben, std::find() nutzen. Das liefert dann list.end() zurueck, wenn das gesuchte objekt nicht in der liste ist

Ich will damit erreichen, daß das if ausgeführt wird wenn der iterator auf dem objekt steht, das ich suche...

typedef std::map<Coordinate, list<Stellarobject*> > Galaxy_map;
typedef Galaxy_map::value_type map_type;

Galaxy_map m_map; // <- Variable, d.h. diese mußt du in deinen Sourcen angeben!
};

Die typedefs benutzt man extra, damit man nicht immer explizit die komplette template-Definition hinschreiben muß (z.B. bei Iteratoren), d.h.

Galaxy_map::iterator it = m_map.find(...);

ist kürzer und eleganter als

std::map<Coordinate, list<Stellarobject*> >::iterator = m_map.find(...);

P.S. Ich habe in die Definition extra noch den Namensraum 'std' hinzugefügt, da alle C++ Standard Typen dort enthalten sind. (deswegen kommen evtl. deine Compiler-Fehler)

Ich habe jetzt mal versucht, die Änderungen von Pumuckel einzuarbeiten, aber ich hänge (den Compilermeldungen nach zu urteilen) immernoch bei den Deklarationen der Listen mit den Pointern.

Da es wohl kaum Sinn mach, alles schnipselweise zu posten (am Ende lass ich was wichtiges aus) hier nochmal der gesamte Code.

#ifndef GALAXYMAP_HPP
#define GALAXYMAP_HPP

#include "Stellarobject.hpp"
#include "Starsystem.hpp"
#include "Coordinate.hpp"

#include <map>
#include <list>

class Galaxymap
{
	public:
		void add_item(Stellarobject *new_stellar, int new_x_pos, int new_y_pos);
		void remove_item(Stellarobject *curr_stellar, int x_pos, int y_pos);

	private:

		int x_size;
		int y_size;

		typedef std::map<Coordinate, list<Stellarobject*> > Galaxy_map;
		typedef Galaxy_map::value_type map_type;
		Galaxy_map Curr_map;
};
#endif

#include "Galaxymap.hpp"

void Galaxymap::add_item(Stellarobject *new_stellar, int new_x_pos, int new_y_pos)
{
	//empty field in map?
	if(Curr_map.find(Coordinate(new_x_pos,new_y_pos)) == Curr_map.end())
	{
		//yes, so a new list has to be created and the new item has to be put in it
		list<Stellarobject*> new_list;
		new_list.push_back(new_stellar);
		Curr_map.insert(map_type(Coordinate(new_x_pos,new_y_pos), list<Stellarobject*>(new_list)));
	}
	else
	{
		//no, the item just has to be put into the existing list
		list<Stellarobject*> existing_list = Curr_map.find(Coordinate(new_x_pos, new_y_pos));
		existing_list.push_back(new_stellar);
	}
}

void Galaxymap::remove_item(Stellarobject *curr_stellar, int x_pos, int y_pos)
{
	//Is there a list at the coordinates?
	list<Stellarobject*>::iterator it = Curr_map.find(Coordinate(x_pos,y_pos));

	if(it = Curr_map.end())
	{
		//No, there is no list which means that there is nothing at all
		cout << "Failed to find object at position" << x_pos << " " << y_pos << "(Map empty)" << endl;
	}
	else
	{
		//There is a list, so we have to search it for the object
		list<Stellarobject*> temp_list = it;

		list<Stellarobject*>::iterator new_it;

		new_it = temp_list.find(curr_stellar);
		if(new_it == temp_list.end())
		{
		cout << "Object wasn´t in the list" << endl;
		}
		else
		{
			delete *new_it;
			temp_list.erase(new_it);
		}
	}
}

Und das sagt der Compiler dazu:

Galaxymap.cpp: In member function void Galaxymap::add_item(Stellarobject*, int, int)': Galaxymap.cpp:16: error: conversion from \std::_Rb_tree_iterator<std::pair<const Coordinate, std::list<Stellarobject*, std::allocator<Stellarobject*> > > >' to non-scalar type `std::list<Stellarobject*, std::allocator<Stellarobject*> >' requested
Galaxymap.cpp: In member function void Galaxymap::remove_item(Stellarobject*, int, int)': Galaxymap.cpp:26: error: could not convert((&it) <unknown operator> ((const std::_Rb_tree_iterator<std::pair<const Coordinate, std::list<Stellarobject, std::allocator<Stellarobject*> > > >&)((const std::_Rb_tree_iterator<std::pair<const Coordinate, std::list<Stellarobject*, std::allocator<Stellarobject*> > > >)(&(((std::map<Coordinate, std::list<Stellarobject, std::allocator<Stellarobject*> >, std::less<Coordinate>, std::allocator<std::pair<const Coordinate, std::list<Stellarobject*, std::allocator<Stellarobject*> > > > >)((Galaxymap)this)) + 8u)->std::map<_Key, _Tp, _Compare, _Alloc>::end [with _Key = Coordinate, _Tp = std::list<Stellarobject*, std::allocator<Stellarobject*> >, _Compare = std::less<Coordinate>, _Alloc = std::allocator<std::pair<const Coordinate, std::list<Stellarobject*, std::allocator<Stellarobject*> > > >]()))))' to bool' Galaxymap.cpp:34: error: conversion from \std::_Rb_tree_iterator<std::pair<const Coordinate, std::list<Stellarobject*, std::allocator<Stellarobject*> > > >' to non-scalar type `std::list<Stellarobject*, std::allocator<Stellarobject*> >' requested
Galaxymap.cpp:38: error: 'class std::list<Stellarobject*, std::allocator<Stellarobject*> >' has no member named 'find'
Galaxymap.cpp:39: error: no match for 'operator==' in 'new_it == (&temp_list)->std::list<_Tp, _Alloc>::end [with _Tp = Stellarobject*, _Alloc = std::allocator<Stellarobject*>]()'
C:/Dev-Cpp/bin/../lib/gcc/mingw32/3.4.2/../../../../include/c++/3.4.2/bits/stl_tree.h:209: note: candidates are: bool std::_Rb_tree_iterator<_Tp>::operator==(const std::_Rb_tree_iterator<_Tp>&) const [with _Tp = std::pair<const Coordinate, std::list<Stellarobject*, std::allocator<Stellarobject*> > >]
Galaxymap.cpp:45: error: type `struct std::pair<const Coordinate, std::list<Stellarobject*, std::allocator<Stellarobject*> > >' argument given to `delete', expected pointer
Galaxymap.cpp:46: error: no matching function for call to std::list<Stellarobject*, std::allocator<Stellarobject*> >::erase(std::\_Rb\_tree_iterator<std::pair<const Coordinate, std::list<Stellarobject*, std::allocator<Stellarobject*> > > >&)' C:/Dev-Cpp/bin/../lib/gcc/mingw32/3.4.2/../../../../include/c++/3.4.2/bits/list.tcc:96: note: candidates are: typename std::list<\_Tp, \_Alloc>::iterator std::list<\_Tp, \_Alloc>::erase(std::\_List\_iterator<\_Tp>) \[with \_Tp = Stellarobject*, _Alloc = std::allocator<Stellarobject*>\] C:/Dev-Cpp/bin/../lib/gcc/mingw32/3.4.2/../../../../include/c++/3.4.2/bits/stl\_list.h:894: note: std::\_List\_iterator<\_Tp> std::list<\_Tp, \_Alloc>::erase(std::\_List\_iterator<\_Tp>, std::\_List\_iterator<\_Tp>) \[with \_Tp = Stellarobject*, \_Alloc = std::allocator<Stellarobject*>\] C:/Dev-Cpp/bin/../lib/gcc/mingw32/3.4.2/../../../../include/c++/3.4.2/bits/stl\_function.h: In member functionbool std::less<_Tp>::operator()(const _Tp&, const _Tp&) const [with _Tp = Coordinate]':
C:/Dev-Cpp/bin/../lib/gcc/mingw32/3.4.2/../../../../include/c++/3.4.2/bits/stl_tree.h:1102: instantiated from typename std::\_Rb\_tree<\_Key, \_Val, \_KeyOfValue, \_Compare, \_Alloc>::iterator std::\_Rb\_tree<\_Key, \_Val, \_KeyOfValue, \_Compare, \_Alloc>::find(const \_Key&) \[with \_Key = Coordinate, \_Val = std::pair<const Coordinate, std::list<Stellarobject*, std::allocator<Stellarobject*> > >, \_KeyOfValue = std::\_Select1st<std::pair<const Coordinate, std::list<Stellarobject*, std::allocator<Stellarobject*> > > >, \_Compare = std::less<Coordinate>, \_Alloc = std::allocator<std::pair<const Coordinate, std::list<Stellarobject*, std::allocator<Stellarobject*> > > >\]' C:/Dev-Cpp/bin/../lib/gcc/mingw32/3.4.2/../../../../include/c++/3.4.2/bits/stl\_map.h:498: instantiated fromtypename std::_Rb_tree<_Key, std::pair<const _Key, _Tp>, std::_Select1st<std::pair<const _Key, _Tp> >, _Compare, _Alloc>::iterator std::map<_Key, _Tp, _Compare, _Alloc>::find(const _Key&) [with _Key = Coordinate, _Tp = std::list<Stellarobject*, std::allocator<Stellarobject*> >, _Compare = std::less<Coordinate>, _Alloc = std::allocator<std::pair<const Coordinate, std::list<Stellarobject*, std::allocator<Stellarobject*> > > >]'
Galaxymap.cpp:6: instantiated from here
C:/Dev-Cpp/bin/../lib/gcc/mingw32/3.4.2/../../../../include/c++/3.4.2/bits/stl_function.h:227: error: no match for 'operator<' in '__x < __y'

Am besten du erzeugst dir für jede Typ-Definition ein eigenes typedef:

typedef std::list<Stellarobject*> ObjectList; // sorry, hier hatte ich auch erst std:: vergessen (war natürlich nur ein Test, ob du es kapiert hast -)

typedef std::map<Coordinate, ObjectList > Galaxy_map;

Nun kannst du einfach

ObjectList new_list;

schreiben.

Die restlichen Fehler muß du dann Zeile für Zeile durchgehen (oftmals werden dann Folgefehler angezeigt, die dann bei Eliminierung der ersten Fehler verschwinden).

Aber nur durch die Fehler versteht man C++ richtig (auch wenn die Fehlerbeschreibungen nicht gerade einfach sind - insbesondere bei den komplexen template-Definitionen).

P.S. sorry, hatte bei meinem ersten Posting die Variablen-Deklaration 'Map mmap' vergessen -)

Was ich aber immernoch nicht verstehe, ist wie ich aus meiner Map nun die Liste bzw. aus der Liste das konkrete Objekt extrahiere.
Mit find() erhalte ich ja nur einen Iterator, der auf den Key zeigt, an dem die Liste ist, oder einen Iterator, der auf das Ende der Map zeigt, wenn der Key nicht drin ist.

Aber wie hole ich mit einem Iterator nun die Liste oder besser nen Zeiger auf die Liste?

Das hier funktioniert einfach nicht, aber was ist daran falsch?

Galaxy_map::iterator it = Curr_map.find(Coordinate(new_x_pos, new_y_pos));
		Stellar_list existing_list = it;

Folgendes

Stellar_list existing_list = *it;

habe ich schon vor einer Weile ausprobiert, und ich bekomme damit immernoch die Fehlermeldung

Galaxymap.cpp:17: error: conversion from `std::pair<const Coordinate, std::list<Stellarobject*, std::allocator<Stellarobject*> > >' to 
non-scalar type `std::list<Stellarobject*, std::allocator<Stellarobject*> >' requested

Ich habs....

Stellar_list existing_list = it->second;

Man muss natürlich aus dem Paar (Key,Value) den Value aussuchen...

pumuckl schrieb:

list<Stellarobject*>:: iterator it;

		bool delete_success = false;

		for (it = temp_list.begin(); it != temp_list.end(); ++it)
		{
			if(it == curr_object)
			{
				delete *it;
				temp_list.erase(it);
				delete_success = true;
			}
		}

versuchs mal mit std::find, das liefert dir auch gleich den list::iterator, fuer den du dann erase() aufrufen kannst

Ist das nicht falsch? Nach der Beschreibung der STL hat doch nur die map eine find() Funktion, nicht aber die List, oder?

Was mich aber immernoch verwundert, sind folgende Fehlermeldungen:

C:/Dev-Cpp/bin/../lib/gcc/mingw32/3.4.2/../../../../include/c++/3.4.2/bits/stl_function.h: In member function bool std::less<\_Tp>::operator()(const \_Tp&, const \_Tp&) const \[with _Tp = Coordinate\]': C:/Dev-Cpp/bin/../lib/gcc/mingw32/3.4.2/../../../../include/c++/3.4.2/bits/stl\_tree.h:1102: instantiated fromtypename std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::find(const _Key&) [with _Key = Coordinate, _Val = std::pair<const Coordinate, std::list<Stellarobject*, std::allocator<Stellarobject*> > >, _KeyOfValue = std::_Select1st<std::pair<const Coordinate, std::list<Stellarobject*, std::allocator<Stellarobject*> > > >, _Compare = std::less<Coordinate>, _Alloc = std::allocator<std::pair<const Coordinate, std::list<Stellarobject*, std::allocator<Stellarobject*> > > >]'
C:/Dev-Cpp/bin/../lib/gcc/mingw32/3.4.2/../../../../include/c++/3.4.2/bits/stl_map.h:498: instantiated from `typename std::_Rb_tree<_Key, std::pair<const _Key, _Tp>, std::_Select1st<std::pair<const _Key, _Tp> >, _Compare, _Alloc>::iterator std::map<_Key, _Tp, _Compare, _Alloc>::find(const _Key&) [with _Key = Coordinate, _Tp = std::list<Stellarobject*, std::allocator<Stellarobject*> >, _Compare = std::less<Coordinate>, _Alloc = std::allocator<std::pair<const Coordinate, std::list<Stellarobject*, std::allocator<Stellarobject*> > > >]'
Galaxymap.cpp:6: instantiated from here
C:/Dev-Cpp/bin/../lib/gcc/mingw32/3.4.2/../../../../include/c++/3.4.2/bits/stl_function.h:227: error: no match for 'operator<' in '__x < __y'

Hier Zeile 6 der Galaxymap.cpp:

if(Curr_map.find(Coordinate(new_x_pos,new_y_pos)) == Curr_map.end())

Was bitte will mir der Compiler mit dem Salat sagen??

EDIT:

Habe hier im Forum was gefunden, bei nem Thread, wo jemand fast dasselbe vorhatte wie ich und auch denselben Fehler bekam. Als Lösung wurde folgendes gepostet:

.filmor schrieb:

Maps werden immer nach ihrem Schlüsseltyp sortiert. Damit das funktioniert, brauchst du ein Vergleichskriterium.
Standardmäßig ist der Comparetyp std::less<KeyType> und std::less ist mit dem <-Operator definiert.
Du hast also 3 Möglichkeiten, den Code zum Laufen zu bringen:
1. Du schreibst einen <-Operator für MyClass (ist aber nur sinnvoll, wenn ein solcher Vergleich tatsächlich logisch möglich ist)
2. Du spezialisierst das std::less-Template für deine Klasse
3. Du schreibst eine eigene Vergleichsfunktion (das Sinnvollste, wenn du nur in einem Kontext eine solche Map anlegst.

Mein Problem ist, daß ich leider keine der drei möglichen Lösungen nachvollziehen kann und auch nicht weiss, welche davon nun für mich die einfachste/effektivste wäre.

Ich glaube zu verstehen, daß es darum geht, der STL beizubringen, wie sie meine Koordinaten nach Größe sortieren kann. Da wäre ja logisch einfach (entweder X oder Y Wert höher gewichten), aber wie und vor allem wo muss ich das implementieren.
Wäre für Codebeispiele sehr dankbar!

.filmor schrieb:

Maps werden immer nach ihrem Schlüsseltyp sortiert. Damit das funktioniert, brauchst du ein Vergleichskriterium.
Standardmäßig ist der Comparetyp std::less<KeyType> und std::less ist mit dem <-Operator definiert.
Du hast also 3 Möglichkeiten, den Code zum Laufen zu bringen:
1. Du schreibst einen <-Operator für MyClass (ist aber nur sinnvoll, wenn ein solcher Vergleich tatsächlich logisch möglich ist)
2. Du spezialisierst das std::less-Template für deine Klasse
3. Du schreibst eine eigene Vergleichsfunktion (das Sinnvollste, wenn du nur in einem Kontext eine solche Map anlegst.

Mein Problem ist, daß ich leider keine der drei möglichen Lösungen nachvollziehen kann und auch nicht weiss, welche davon nun für mich die einfachste/effektivste wäre.

Ich glaube zu verstehen, daß es darum geht, der STL beizubringen, wie sie meine Koordinaten nach Größe sortieren kann. Da wäre ja logisch einfach (entweder X oder Y Wert höher gewichten), aber wie und vor allem wo muss ich das implementieren.
Wäre für Codebeispiele sehr dankbar!

Genau darum gehts, um ein Vergleichskriterium. Auf welcher Ebene du dieses Kriterium implementierst, ist die Sache die du entscheiden musst, und das sind die obigen drei Punkte. Wie du vielleicht weißt, hat die std::map nicht nur den key_type und den value_type als Templateparameter, sondern (neben dem Allocator, den alle container haben) auch einen sogenannten Comparator, das ist ein Functor, der zwei key_types miteinander vergleicht. Default für den Comparator ist std::less.

Ich roll mal die Punkte von filmor von hinten auf: Punkt 3 bedeutet, einen eigenen Comparator zu schreiben. Das ist eine Klasse, die folgendes besitzen muss:
- einen Standardkonstruktor (kannder implizit durch den COmpiler generierte sein)
- einen bool operator()(const T&, const T&) , der die zu vergleichenden Objekte streng ordnet. Beispiel hierfuer wäre

struct CoordCompare {
  bool operator() (const Coordinate& a, const Coordinate& b) {
    //Wenn x-Koordinaten gleich sind ordne nach y-Koordinaten, sonst nach x-Koordinaten
    return (a.x==b.x) ? (a.y<b.y) : (a.x<b.x);
  }
};

//benutzung dann wie folgt:
std::map<Coordinate, Stellarobject*, CoordCompare>; //benutze CoordCompare fuer die Ordnung der Coordinates

Zweite Möglichkeit ist, dem Compiler statt einem eigenen Comparator nur zu sagen, wie er std::less<> für Coordinaten zu verstehen hat, das waere dann eine Spezialisierung des templates:

namespace std {
template<>
struct less<Coordinate> {
  bool operator() (const Coordinate& a, const Coordinate& b) {
    //Wenn x-Koordinaten gleich sind ordne nach y-Koordinaten, sonst nach x-Koordinaten
    return (a.x==b.x) ? (a.y<b.y) : (a.x<b.x);
  }
};
}

//Nutzung:
std::map<Coordinate, Stellarobject*>; //benutzt automatisch die Spezialisierung von std::less<Coordinate>

Das sieht gleich aus, allerdings musst du jetzt bei Containern (und bei anderen Strukturen, die std::less<> nutzen) nicht mehr explizit den Comparator angeben sondern kannst dich darauf verlassen, dass der Compiler immer deine Spezialisierung findet.

Das allgemeinste ist Punkt 1, nämlich die Angabe eines operator< für deine Coordinate Klasse. Damit kannst du nichtnur Abfragen wie "if (coordiA < coordiB)" realisieren. std::less benutzt nämlich defaultmäßig (das heißt, wenn man nicht wie in Punkt 2 ne Spezialisierung angibt) den operator< (Die Implementierung besteht meist aus der kleinen Zeile "return a<b;"). Deshalb hat dein Compiler auch gemeckert, weil std::less den op< für Coordinate aufgerufen hat, dens aber nicht gibt. Die Implementierung ist simpel:

struct Coordinate {
//...

public:
  bool operator< (const Coordinate& other) const {
    //Wenn x-Koordinaten gleich sind ordne nach y-Koordinaten, sonst nach x-Koordinaten
    return (x==other.x) ? (y<other.y) : (x<other.x);
  }
//...
};

(Bin mir grad nicht ganz sicher ob man op< auch außerhalb der Klasse mit zwei Argumenten implementieren kann und welche Version die Gurus da befürworten, aber so funktionierts auf jeden Fall)

Alle drei Varianten funktionieren für deine map gleich gut.

matching function for call to `Galaxymap::add_item(Starsystem&, int&, int&)'
Galaxymap.hpp:15: note: candidates are: void Galaxymap::add_item(Stellarobject*, int, int)

und das, obwohl Starsystem (wie von Th erklärt) von der abstrakten Klasse Stellarobject erbt.

Was muss ich an dem Code noch ändern?

battlefield.add_item(new_System, x_pos, y_pos);

class Starsystem : public Stellarobject

#ifndef STELLAROBJECT_HPP
#define STELLAROBJECT_HPP

class Stellarobject
{
};

#endif

EDIT: Schon rausgefunden,

battlefield.add_item(&new_System, x_pos, y_pos);

war die Lösung.

Wobei... Ist das richtig so? Und warum kann ich es nur als Referenz, nicht aber als Zeiger oder "ohne alles" (was wohl eine Kopie wäre dann) übergeben?

Starsystem *new_system = new Starsystem(...); // Parameter?
battlefield.add_item(new_System, x_pos, y_pos);

Davor hab ich aber noch ne andere Frage:
Wie bekomme ich denn die Zeiger auf Stellarobjekte, nachdem ich sie aus der Liste wieder herausgeholt habe, wieder zu Instanzen von Starsystem, Blackhole etc. "zurückgebaut"?

Muss ich da casten?

Meine Funktion sieht jetzt erstmal so aus:

//Get all the systems out of the map and render them
void Game::render_starsystems()
{
	for (int n=0;n<field_width;n++)
	{
		for (int m=0;m<field_height;m++)
		{
			if(battlefield.check_pos(n,m)) // Do this only if mapfield is occupied
			{
				list<Stellarobject*> temp_list;
				temp_list=battlefield.get_list(n,m); //Get the list out of occupied field

				list<Stellarobject*>::iterator it = temp_list.begin(); //Iterate over the list and render the lists objects

				while (it != temp_list.end())
				{
					it->render();
					it++;
				}
			}
		}
	}
}

und der Compiler meckert, weil er render() nicht kennt (die ist ja auch nur in der Klasse Starsystem definiert, nicht in Stellarobject).

Der beste Ansatz für das Rendern besteht dadrin, einfach eine virtuelle Methode 'render' in der Basisklasse zu definieren, welche dann von den abgeleiteten Klassen implementiert wird.

Je nach Anzahl der abgeleiteten Objekte mußt du für dich entscheiden, ob du evtl. noch Zwischen-(Basis)klassen erstellst, welche Gemeinsamkeiten mehrerer Klassen implementieren.
Der letzte Ausweg sollte sein, ein "dynamic-cast" zu benutzen, um zu schauen, um welches Stellarobjekt es sich handelt.
Sobald du merkst, daß du an verschiedenen Stellen im Source "switches" benötigst, dann überleg dir, ob du nicht besser eine virtuelle Methode dafür bereitstellst.

P.S.
Deine Methode 'get_list' sollte besser eine Referenz auf die Liste zurückgeben, damit die Liste nicht beim Rendern immer kopiert wird (wenn auch nur die Zeiger):

Stellar_list & temp_list = battlefield.get_list(n,m); // typedef benutzen!!!

So langsam kriege ich selber wieder Lust, an einem Weltraumspiel zu arbeiten (vor Jahren hatte ich mal ein Spiel namens "Universe" entwickelt, bevor ich vorletztes Jahr bei Ascaron an "DarkStar One" mitprogrammiert hatte).

Gibts da was besonders sinnvolles im Web zu? Ich finde immerwieder Tonnen von Sachen zu den Basics (Variablen, Arrays, if,for, while...) aber zu komplexeren Themen hab ich noch nichts gesehen, also wäres nett, wenn du mir nen Link oder Buchtitel anempfehlen könntest (oder natürlich auch jeder andere hier).

Und wofür soll ich in dem Code ein typedef benutzen?

Um mal was zum Hintergrund der Sache zu erzählen:
Ich arbeite jetzt seit nem guten Jahr immerwieder hobbymäßig an meinem Spiel, aber das Coden ist in der Vergangenheit stark in den Hintergrund getreten, da ich mich eher mit Zeichnen und Designdoc schreiben beschäftigt habe.

Den typedef habe ich extra benutzt, damit man nicht immer wieder die komplette template-Schreibweise hinschreiben muß.
Außerdem hat es den Vorteil, daß du evtl. den verwendeten Datentypen leichter wechseln könntest (z.B. wenn du doch lieber std::vector statt std::list benutzen willst), nämlich nur an der einen Stelle in der Header-Datei.

Mir hat es den Anschein, du programmierst einfach so drauf los und das kann, je größer das Programm wird, immer schwieriger werden, ein gutes und einheitliches Design zu verwenden.

Du solltest zuerst damit anfangen, dir die Basisklassen und darauf aufbauenden Klassen genau zu überlegen, ehe du einzelne Methoden implementierst.
Ein gutes Klassendesign führt meistens zu kleineren und überschaubareren Programmen.

Ich will dir auf keinen Fall den Mut nehmen weiterzumachen, sondern dich einfach nur auf bestimmte Fallstricke bei C++ hinweisen.

Und mit welcher GUI willst du denn die Sterne und schwarzen Löcher etc. zeichnen?

Wenn du willst, kann ich dir ja bei deinem Projekt helfen.
Ich selber entwickle auch Spiele (privat zwar keine 3D, aber trotzdem ansehbar, s.a. http://www.c-plusplus.net/forum/viewtopic-var-t-is-193889.html