Discussion :

[lovecpp]

Bonjour,

Alors voila mon problème : j'utilise un vecteur pour stocker des pointeurs alloués dynamiquement. Mais lorsque j'utilise les itérateurs pour détruire un à un les objets du vecteur, j'obtiens une segfault. Encore plus surprenant, en mettant quelques cout, je m'aperçois que la taille de vecteur ne fait que un, alors que le programme passe une deuxième fois dans la boucle...ça a donc l'air d'être les itérateurs qui foirent. Mon bout de code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
cout << "Taille des plugins : " << plugins.size() << endl;
 
                for(vector<plugin*>::iterator it_ = plugins.begin(); it_ != plugins.end(); ++it_)
                {
                    cout << "Itération" << endl;
                    delete *it_;
                    plugins.erase(it_);
                }

Avec les cout, j'obtiens comme sortie :
Taille des plugins : 1
Itération
Itération --->> segfault (pas très surprenant...xD)

En sachant (je le répète) que mon vecteur contient des pointeurs d'objets plugins alloués dynamiquement via new, et que le vecteur plugins a été intialisé par copie.

Plus précisément, j'ai une fonction vector<plugin*> get_installed_plugins() qui créer un vecteur en local, le remplit, et renvoie son vecteur contenant les instances de la classe plugin...Je ne sais pas si ça influe...
En tout cas, je peux très bien accèder à l'élement 0 du vecteur, le manipuler et le détruire sans segfault ; le seul problème viens du fait que la vérification it_ != plugins.end() pose apparament problème...

Si quelqu'un a une idée
Merci d'avance.

[edit]Je viens de trouver la réponse tout seul...je ne savais pas que erase() invalidait l'itérateur concerné. (ouais, j'aurais peut être dût googler avant de poser, i know... )

[Laurent Gomila]

Encore plus rapide que Googler : regarder dans la

[koala01]

Salut,

Je suis sur que, si tu utilisais la post incrémentation cela irait bien mieux

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
for(vector<plugin*>::iterator it_ = plugins.begin(); it_ != plugins.end(); it_++)
{
   /*...*/
}

[nikko34]

Salut,
Je suis sur que, si tu utilisais la post incrémentation cela irait bien mieux

euh...pourquoi? il a tout à fait raison d'utiliser la pré incrémentation sur un objet.

[Laurent Gomila]

Ca ne changerait rien, l'itérateur serait tout autant invalide.

[sylvie83]

Il faut savoir que dans une boucle for le fait d'utiliser ++i ou i++ ne change rien au résultat du calcul sur i.

Dans son cas, il suffit de ne rien mettre en dernier paramètre du for car l'iterator va évoluer tout seul avec les erase successifs:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
for(vector<plugin*>::iterator it_ = plugins.begin(); it_ != plugins.end();)
                {
                    cout << "Itération" << endl;
                    delete *it_;
                    plugins.erase(it_);
                }

[Laurent Gomila]

Dans son cas, il suffit de ne rien mettre en dernier paramètre du for car l'iterator va évoluer tout seul avec les erase successifs:

Non... Ca sert à quoi de faire des jolies FAQ

[screetch]

c'est contre performant d'effacer un element du vector comme ca. ce que tu souhaites faire c'est effacer la memoire pour chaque iterator puis vider le container.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
cout << "Taille des plugins : " << plugins.size() << endl;
 
                for(vector<plugin*>::iterator it_ = plugins.begin(); it_ != plugins.end(); ++it_)
                {
                    cout << "Itération" << endl;
                    delete *it_;
                    //plugins.erase(it_); pas besoin, et contre performant
                }
                plugins.clear(); // on les efface tous

ou bien meme

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
std::vector<Plugin*>().swap(plugins);

qui est plus idiomatique.

Pour revenir au probleme, si tu tiens a conserver ton paradigme d'effacer, tu ne fais pas une boucle for mais une boucle while et ca sera plus clair.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
cout << "Taille des plugins : " << plugins.size() << endl;
 
vector<plugin*>::iterator it = plugins.begin(); // plugins.rbegin() me ferait avoir moins de crise cardiaque....
while(it != plugins.end())
{
  cout << "Itération" << endl;
  delete *it;
  it = plugins.erase(it);
}

ca me parait plus clair qu'une boucle for et tres sûr. et ca a le bon gout de pas planter.

[yan]

Si tu parle de performance alors faut mieux faire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
vector<plugin*>::iterator it = plugins.begin(); 
vector<plugin*>::iterator it_end = plugins.end(); // on appel une fois plugins.end()
while(it != it_end)
{
  cout << "Itération" << endl;
  delete *it;
  it = plugins.erase(it);
}

ou bien mieux encore

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
.
.
.
for_each(plugins.begin() , plugins.end(), delete_ptr);
 plugins.clear();
.
.
.
//avec
 
void delete_ptr(plugin* ptr) {delete ptr;};

utiliser les algo de la STL peut aller beaucoup plus vite que le parcours codé par toi même. Tu peu tester avec un vector sous visual, c'est bluffant

[screetch]

c'est du aux iterateurs checkes de visual

definit _HAS_ITERATOR_DEBUGGING=0 et tu verras une grosse difference de performance dans l'utilisation des iterateurs (la raison pour laquelle ca va plus vite dans la STL est que la STL checke les iterateurs au debut et ne les check plus ensuite)

quand a l'utilisation d'une variable pour end(), le code etant inliné on sent a peine la difference.

C'est surtout le fait de retirer un element au debut du vecteur qui coute cher, imagine que ce que je fais c'est un appel de fonction (end()) par boucle, ce que fait plugins.erase(it) c'est l'appel des constructeurs de copie pour deplacer les elements un par un. C'est pas comparable...

[yan]

quand a l'utilisation d'une variable pour end(), le code etant inliné on sent a peine la difference.

je ne suis pas sur que tout les compilot le face systématiquement

c'est du aux iterateurs checkes de visual
definit _HAS_ITERATOR_DEBUGGING=0 et tu verras une grosse difference de performance dans l'utilisation des iterateurs (la raison pour laquelle ca va plus vite dans la STL est que la STL checke les iterateurs au debut et ne les check plus ensuite)

en release _HAS_ITERATOR_DEBUGGING n'est pas mis à 0??

j'avais fait des teste entre utiliser les iterateurs et utiliser les algo. Le seul moyen que j'ai trouvé pour être aussi rapide que le for_each avec un vector (je pas vu de difference avec d'autre contener ) et de parcourir la mémoire comme un tableau plutôt qu'avec les iterator

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
vector<int> vect(10000);
.
.
.
vector<int>::iterator it = vect.begin();
vector<int>::iterator itEnd = vect.end();
 
//le plus lent
while (it!=itEnd )
{
blabla(*it);
++it;
}
 
//beaucoup plus rapide
for_each(vect.begin(),vect.end(),&blabla);
//equivalent  à (pour un vector)
int nb =vect.size();
int * pInt = &vect[0];
int * pend=&vect[nb -1]+1;
while (pInt !=pend)
{
blabla(*pInt );
++pInt ;
}

[screetch]

non ce n'est pas ajouté en release, il faut le mettre a la main!