Dovremmo cancellare prima o dopo la cancellazione di un puntatore nel vettore?

Question

Dovremmo eliminare prima o dopo erase. La mia comprensione è che entrambi stanno bene. È corretto?

Inoltre, è possibile che non si voglia eliminare l'elemento durante la cancellazione? Credo che ci deve essere, altrimenti, il erase sarà felice di assumersi la responsabilità.

std::vector<foo*> bar; 
... 
for (vector<foo*>::iterator itr = bar.begin(); itr != bar.end(); itr++) 
{ 
    delete (*itr); //before OR 
    bar.erase(itr); 
    delete (*itr); //after??? 
} 

Answer 1

"itr" deve essere utilizzato in questo modo;

Tuttavia, preferisco prima cancellare tutti gli elementi e quindi cancellare il vettore;

for (vector<foo*>::iterator itr = bar.begin(); itr != bar.end(); ++itr) 
    delete (*itr); 
bar.clear(); 

Answer 2

L'utilizzo di un iteratore per cancellare un elemento invalida l'iteratore. Dovresti cancellare l'oggetto prima che venga cancellato.

Si dovrebbe anche usare il valore di ritorno da cancellare per la successiva iterazione del ciclo.

Answer 3

Fare un erase invaliderà l'iteratore vector. Pertanto, *iter invocherà un comportamento non definito. Quindi è necessario fare il delete dopo il erase. Inoltre, non è possibile erase gli elementi da un vector durante l'iterazione attraverso di esso (a causa dello stesso motivo, iter non è valido, quindi iter++ non è valido). In questo caso è possibile rimuovere la chiamata erase dall'interno del loop e fare clear del vettore all'esterno del ciclo.

Answer 4

La natura del vettore che cancellare primo elemento provoca intera matrice di spostare in avanti, per ridurre questa operazione prova seguente:

std::vector<foo*> v1; 
//... 
while(!v1.empty()) 
{ 
    delete v1.back(); 
    v1.pop_back(); 
} 

proposito - questo metodo non inficia alcuna iteratori (solo sugli articoli cancellati)

Answer 5

Inoltre, è possibile che non si voglia eliminare l'elemento durante la cancellazione?

Come potrebbe il vettore sapere se qualcun altro ha bisogno degli oggetti puntati? Come potrebbe anche sapere che le punte sono immagazzinate sul mucchio? È perfettamente possibile avere puntatori a oggetti statici o automatici nel vettore, o anche puntatori penzolanti.

C++ 0x consente di esprimere che il vettore dovrebbe possedere le pointees:

std::vector<std::unique_ptr<foo>> vec; 

Ora non c'è bisogno di eliminare manualmente qualsiasi cosa. Cancellando i puntatori unici, anche le loro rispettive punte vengono cancellate. I contenitori di puntatori nativi sono molto rari nel moderno C++.

Se non si dispone di un compilatore C++ 0x, è possibile utilizzare std::vector<boost::shared_ptr<foo> > o boost::ptr_vector<foo>. I compilatori moderni forniscono shared_ptr nello spazio std::tr1 o std anche se si è #include <memory>.