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:

1. 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.

2. 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?

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

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.