Verschiedene Objekte in einem Array

Hi,

ich habe eine Weltkarte deren Punkte in einem Array repräsentiert sind.

In jedem der Punkte könnte ein bestimmtes Objekt mit spezifischen Eigenschaften stehen. Diese Objekte haben einen gemeinsamen Parent.

Ich frage mich jetzt wie ich in c++ die Objekte irgendwie in dieses Array speichern kann um dann auf sie zurück zu greifen.
Problem ist, dass ja jedes Objekt eine andere Klasse haben kann.

Hier mal etwas pseudocode:

class World() {
public:
 ? getObjectAtPoint(int x, int y) {return this->array[x][y];}
 setObjectAtPoint(object, int x, int y) {this->array[x][y] = object;}
 ? array[500][500];
}

class Object {
protected:
 int allgmEigenschaft;
}

class Baum : Object {
private:
 int spezEigenschaft1;
}

class Stein : Object {
private:
 int spezEigenschaft2;
}

int main() {
 World world = new World();
 world->setObjectAtPoint(Baum, 1, 1);
 world->setObjectAtPoint(Stein, 2, 4);

 int foo = world->getObjectAtPoint(1,1).allgEigenschaft();
 int bar = world->getObjectAtPoint(1,1).spezgEigenschaft();
}

Wie kann man dies am besten machen?

drakon

class World() { 
public: 
 Object* getObjectAtPoint(int x, int y) {return this->array[x][y];} 
 setObjectAtPoint(object, int x, int y) {this->array[x][y] = object;} 
 Object* array[500][500]; 
}

Das wäre prinzipiell der Weg, wie man das macht (man benutzt da aber eher einen anderen Container und kein Array). Dann brauchst du aber eine allgemeine Schnittstelle für die Basisklasse, damit du die Objekte auch benutzen kannst. Wenn du die Objekte da so reinpackst müssen die ja gewisse Gemeinsamkeiten haben und das kannst du so darstellen.
Der private Bereich einer Klasse stellt ja die Implementierung dar. Sie legt fest, wie sich das Objekt verhält, aber die Schnittstelle solltest du allgemein machen.
Object hat dann z.B einen Funktion destroy, welche von den Kindern implementiert wird. Dann kannst du die Funktion aufrufen und je nach Objekt verhält es sich anders.

Ja genauso hab ich es auch gemacht, bekomme aber momentan einen Fehler.
Vorher hatte ich es irgendwie anders hinbekommen, aber dann war nach der 3. Zeile in der "main.cpp" an Punkt 1,1 nicht ein Objekt vom Typ "ObjectTree" sondern nur ein "Object" (der Holzertrag fehlte).

main.cpp:

ObjectTree* objectTree = new ObjectTree(false,5);
	ObjectsContainer* objectsContainer = new ObjectsContainer();
	objectsContainer->setObjectAtPoint(objectTree,1,1);           //FEHLER: ObjectTree*  mit Object* inkompatibel
	Object* object = objectsContainer->getObjectAtPoint(1,1);

ObjectTree.h

#include "Object.h"

class ObjectTree : public Object {
public:
	ObjectTree(int walkable,int holzertrag) {this->walkable = walkable; this->holzertrag = holzertrag;}
	int getHolzertrag() {return this->holzertrag;}
private:
	int holzertrag;
};

Object.h

class Object {
public:
	Object();
	~Object();

	Object(bool walkable) {this->walkable = walkable;}
	bool isWalkable() {return this->walkable;}
	void setWalkable(bool walkable) {this->walkable = walkable;}

protected:
	bool walkable;
};

Object.cpp

#include "Object.h"

Object::Object() {
	this->walkable = true;
}

ObjectsContainer.h

#include "Object.h"

class ObjectsContainer {
public:
	ObjectsContainer();
	Object* getObjectAtPoint(int x, int z);
	void setObjectAtPoint(Object* object, int x, int z);
private:
	Object* objects[513][513];
};

ObjectsContainer.cpp

#include "ObjectsContainer.h"

ObjectsContainer::ObjectsContainer() {
	for(int i = 0; i < 513; i++) {
		for(int j = 0; j < 513; j++) {
			this->objects[i][j] = 0;
		}
	}
}

Object* ObjectsContainer::getObjectAtPoint(int x, int z) {
	return this->objects[x][z];
}

void ObjectsContainer::setObjectAtPoint(Object* object, int x, int z) {
	this->objects[x][z] = object;
}

Was mache ich falsch?

Würde mich nach wie vor über jegliche Hilfe freuen!

Was ist denn jetzt das Problem? Ein Compilerfehler?

Den Destruktor von Object solltest du auf jeden Fall virtual machen, dann "weiß" der Compiler auch später noch, dass es sich beim object um einen ObjectTree handelt.