La suppression de l'élément de vecteur, alors qu'en C++11 de la gamme "pour" boucle?

Non, vous ne pouvez pas. Gamme à base de for est pour quand vous avez besoin pour accéder à chaque élément d'un conteneur une fois.

Vous devez utiliser la normale for boucle ou l'un de ses cousins si vous avez besoin de modifier le conteneur comme vous allez le long, accéder à un élément plus d'une fois, ou autrement effectuer une itération dans un mode non-linéaire à travers le récipient.

Par exemple:

auto i = std::begin(inv);

while (i != std::end(inv)) {
    //Do some stuff
    if (blah)
        i = inv.erase(i);
    else
        ++i;
}

Idéalement, vous ne devriez pas modifier le vecteur lors de l'itération sur elle. Utiliser le erase-remove idiome. Si vous le faites, vous êtes susceptible de rencontrer quelques problèmes. Car, dans un vector un erase invalide tous les itérateurs de début avec l'élément à effacer jusqu'à la end() vous aurez besoin pour vous assurer que votre itérateurs restent valables à l'aide de:

for (MyVector::iterator b = v.begin(); b != v.end();) { 
    if (foo) {
       b = v.erase( b ); //reseat iterator to a valid value post-erase
    else {
       ++b;
    }
}

Note, que vous avez besoin de la b != v.end() test-est. Si vous essayer de l'optimiser comme suit:

for (MyVector::iterator b = v.begin(), e = v.end(); b != e;)

vous allez courir dans UB depuis votre e est invalidée après la première erase appel.

désolé pour necroposting et aussi désolé si mon expertise c++ est dans la manière de ma réponse, mais si vous essayez d'itérer sur chaque point et de faire des changements possibles (telles que l'effacement d'un index), essayez d'utiliser un backwords pour la boucle.

for(int x=vector.getsize(); x>0; x--){

//do stuff
//erase index x

}

lors de l'effacement de l'indice de x, la boucle suivante sera pour l'élément "en face de" la dernière itération. j'espère vraiment que cela a aidé quelqu'un

Je vais montrer l'exemple, l'exemple ci-dessous enlever impair d'éléments de vecteur:

void test_del_vector(){
std::vector<int> vecInt{0, 1, 2, 3, 4, 5};
//method 1
for(auto it = vecInt.begin();it != vecInt.end();){
if(*it % 2){//remove all the odds
it = vecInt.erase(it);
} else{
++it;
}
}
//output all the remaining elements
for(auto const& it:vecInt)std::cout<<it;
std::cout<<std::endl;
//recreate vecInt, and use method 2
vecInt = {0, 1, 2, 3, 4, 5};
//method 2
for(auto it=std::begin(vecInt);it!=std::end(vecInt);){
if (*it % 2){
it = vecInt.erase(it);
}else{
++it;
}
}
//output all the remaining elements
for(auto const& it:vecInt)std::cout<<it;
std::cout<<std::endl;
//recreate vecInt, and use method 3
vecInt = {0, 1, 2, 3, 4, 5};
//method 3
vecInt.erase(std::remove_if(vecInt.begin(), vecInt.end(),
[](const int a){return a % 2;}),
vecInt.end());
//output all the remaining elements
for(auto const& it:vecInt)std::cout<<it;
std::cout<<std::endl;
}

sortie aw ci-dessous:

024
024
024

Gardez à l'esprit, la méthode erase sera de retour la prochaine itérateur de l'itérateur.

De ici , nous pouvons utiliser une méthode de génération:

template<class Container, class F>
void erase_where(Container& c, F&& f)
{
c.erase(std::remove_if(c.begin(), c.end(),std::forward<F>(f)),
c.end());
}
void test_del_vector(){
std::vector<int> vecInt{0, 1, 2, 3, 4, 5};
//method 4
auto is_odd = [](int x){return x % 2;};
erase_where(vecInt, is_odd);
//output all the remaining elements
for(auto const& it:vecInt)std::cout<<it;
std::cout<<std::endl;    
}

Voir ici pour voir comment utiliser std::remove_if.
https://en.cppreference.com/w/cpp/algorithm/remove

Beaucoup plus élégante solution serait de passer à std::list (en supposant que vous n'avez pas besoin d'accès aléatoire rapide).

list<Widget*> widgets ; //create and use this..

Vous pouvez ensuite les supprimer avec .remove_if et C++ foncteur en une seule ligne:

widgets.remove_if( []( Widget*w ){ return w->isExpired() ; } ) ;

Donc ici, je suis en train d'écrire un foncteur qui accepte un argument (le Widget*). La valeur de retour est la condition de supprimer un Widget* à partir de la liste.

Je trouve cette syntaxe acceptable. Je ne pense pas que je pourrais jamais utiliser remove_if pour std::vecteurs -- il y a tellement inv.begin() et inv.end() bruit de là, vous êtes probablement mieux d'utiliser un entier fondé sur l'indice supprimer ou juste un simple vieux régulières itérateur à base de supprimer (comme illustré ci-dessous). Mais vous ne devrait pas vraiment être enlever du milieu d'un std::vector beaucoup de toute façon, le fait de passer à un list pour ce cas de fréquentes moyen de la liste de suppression est conseillé.

Remarque cependant, je n'ai pas de possibilité d'appeler delete sur le Widget*'s qui ont été supprimés. Pour ce faire, il devrait ressembler à ceci:

widgets.remove_if( []( Widget*w ){
bool exp = w->isExpired() ;
if( exp )  delete w ;       //delete the widget if it was expired
return exp ;                //remove from widgets list if it was expired
} ) ;

Vous pouvez également utiliser un itérateur à base de boucle comme ceci:

//                                                             NO INCREMENT v
for( list<Widget*>::iterator iter = widgets.begin() ; iter != widgets.end() ; )
{
if( (*iter)->isExpired() )
{
delete( *iter ) ;
iter = widgets.erase( iter ) ; //_advances_ iter, so this loop is not infinite
}
else
++iter ;
}

Si vous n'aimez pas la longueur de for( list<Widget*>::iterator iter = widgets.begin() ; ..., vous pouvez utiliser

for( auto iter = widgets.begin() ; ...

vous ne pouvez pas supprimer l'itérateur au cours de l'itération de boucle, car itérateur comte obtenir des mésappariements et après une itération, vous auriez invalide itérateur.

Solution:
1) prendre la copie de l'original de vecteur
2) itérer l'itérateur à l'aide de cette copie
2) faire quelques trucs et supprimer à partir du vecteur d'origine.

std::vector<IInventory*> inv;
inv.push_back(new Foo());
inv.push_back(new Bar());
std::vector<IInventory*> copyinv = inv;
iteratorCout = 0;
for (IInventory* index : copyinv)
{
//Do some stuff
//OK, I decided I need to remove this object from 'inv'...
inv.erase(inv.begin() + iteratorCout);
iteratorCout++;
}