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?

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.

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?

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.