Datenstruktur

Hallo,

ich habe folgende Datenstruktur:

std::map<const std::string, Object*>	mObjects;

Sprich eine Map von Objekten, wobei der Key ein eindeutiger Name ist.

In einer Schleife bearbeite ich dann alle Objekte:

ObjectMapIterator itObj = mObjects.begin();
	ObjectMapIterator itObjEnd = mObjects.end();
	for(; itObj != itObjEnd; ++itObj) {
		itObj->second->_notifyCurrentCamera(cam);
		itObj->second->updateRenderQueue(&mRenderQueue);
	}

Nun möchte ich zusätzlich die Möglichkeit anbieten, dass man einzelne Objekte aktivieren/deaktivieren kann. Nur wenn ein Objekt aktiv ist, wird es in der Schleife beachtet.
Mir fallen dazu jetzt 2 Möglichkeiten ein:

Ich mache eine 2. Datenstruktur std::map<string, bool> mObjActive, in der ich mir separat merke, ob ein Objekt aktiv ist. Das "Problem" ist nur, dass ich dann in der Schleife in der jeweiligen Map suchen muss, ob das aktuelle Objekt aktiv ist. Sprich:

for(; itObj != itObjEnd; ++itObj) {
   if(mObjActive[itObj->first]) {
      itObj->second->_notifyCurrentCamera(cam);
      itObj->second->updateRenderQueue(&mRenderQueue);
   }
}

Ich habe also eine minimal miesere Performance.

Ich nehm die Aktiv/Inaktiv Info in die Hauptstruktur auf. Sprich statt

std::map<const std::string, Object*>	mObjects;

hab ich dann sowas:

struct ObjAct { Object* obj; bool isActive; };
std::map<const std::string, ObjAct>	mObjects;

Dann ist die Datenstruktur zwar nicht mehr so schön, aber die Schleife ist performanter:

for(; itObj != itObjEnd; ++itObj) {
   if(itObj->second->isActive) {
      itObj->second->obj->_notifyCurrentCamera(cam);
      itObj->second->obj->updateRenderQueue(&mRenderQueue);
   }
}

Was würdet ihr nehmen?

Ich würde das zweite nehmen, jedoch stattdessen ein pair Template nutzen.

std::map<const std::string, std::pair<bool, Object*> >

l'abra d'or

Ich bin für Lösung 3:
Erweitere direkt die Klasse Object! Aktiv/Inaktiv ist eine Eigenschaft die das Objekt ja gerade ausmachen soll.
Eine weitere Option wäre ableiten, wenn du Object nicht selber verändern kannst. Oder eben dann ein Mapper (deine Lösung 2).

Parallele Listen/std::pair wäre mir zu unsauber. Am Ende entscheidest du dich, dass noch andere Properties hinzu kommen sollen, die dann vllt. nur in einem bestimmten Kontext interessant wären. Aber du musst dann ständig aufpassen, dass sich eine Änderung dann wirklich in allen Teilen auswirkt.