Errore di runtime: mappa/iteratori set incompatibili

Question

ho un errore di runtime "mappa/set iteratori incompatibile" alla riga 8.

void Manager::Simulate(Military* military, Shalishut* shalishut,char* args[]){ 
    Simulation* simulation = Simulation::GetInstance(); 
    Time* time = Time::GetInstance(); 

    multimap<int,Task*>::iterator itTasks; 
    itTasks = simulation->GetTasks().begin(); 
    while(itTasks != simulation->GetTasks().end()){ 
     while (itTasks->second->GetTimeStamp() == time->GetTime()){ /*line 8 - ERROR*/ 
      TaskExecute(itTasks->second,military,shalishut,args); 
      itTasks++; 
     } 
     // Unit take car of vehicles 
     time->TimeIncrease(); 
    } 

} 

Simulation è dichiarata come multimap<int,Task*>. Qual è il problema?

Answer 1

ho intenzione di prendere un ipotesi e dire che la firma Simulation::GetTasks() assomiglia a questo:

multimap<int,Task*> GetTasks() const; 

Questo crea un nuovo multimap (una copia ) ogni volta che si chiama.

Quando si confrontano gli iteratori, entrambi gli iteratori multimap<int,Task*> devono provenire dallo stesso contenitore; poiché stai ricevendo una nuova copia ogni volta che chiami GetTasks(), violi questo vincolo e questa è la fonte del tuo errore. Hai anche un altro problema: le copie multimap temporanee vengono distrutte dopo la dichiarazione in cui sono state create, quindi i tuoi iteratori vengono invalidati istantaneamente.

Hai due possibilità; uno è quello di catturare una copia locale e utilizzare tale copia costantemente:

multimap<int,Task*> tasks = simulation->GetTasks(); 
multimap<int,Task*>::iterator itTasks; 
itTasks = tasks.begin(); 
while(itTasks != tasks.end()){ 
    while (itTasks->second->GetTimeStamp() == time->GetTime()){ 
     TaskExecute(itTasks->second,military,shalishut,args); 
     itTasks++; 
    } 
    // Unit take car of vehicles 
    time->TimeIncrease(); 
} 

altro è avere GetTasks() restituire un riferimento a un persistente multimap , assicurando lo stesso viene utilizzato ogni volta:

multimap<int,Task*> &GetTasks(); 

o un riferimento const:

const multimap<int,Task*> &GetTasks() const; 

Questo ha il vantaggio di evitare il (potenzialmente grande) sovraccarico di copia dello multimap.

Si noti che l'utilizzo di un riferimento const richiede l'utilizzo di const_iterator s per passare attraverso la multimap. Suggerirei di definire entrambi gli accessi const e non-const (C++ sceglierà quello giusto in base a se il puntatore o riferimento Simulation è const), a meno che non si voglia disabilitare la modifica diretta dello multimap sottostante, nel qual caso è possibile definire solo la variante const.