Discussion :

[donkeyquote]

Bonjour à tous !

J'ai trouvé un core dumped dans une appli que je suis en train de développer... je pense qu'il y doit exister un façon élégante de resoudre ce problème.

J'ai un vecteur de la STL qui contient des pointeurs vers des entier. (chaque élément du vecteur contient un pointeur à entier)

Une méthode M(), change la valeur des entiers pointes par le vecteur en sorte que de fois l'entier peut devenir négatif.

Après chaque appel de M(), on va parcourir le vecteur avec un iterateur. Si l'entier pointé est négatif, alors on fait un delete de l'élément négatif pointé et on elimine l'élément pointeur du vecteur qui le pointait.

Le probléme survient quand le dernier élément du vecteur pointé est négatif car il faut l'éliminer, et à ce moment là l'itérateur se perd et voilà le bordel ...

Code :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
 std::vector<int*> V;
// admettons que les éléments pointés sont  {4, -7, 8, 46, 31, -1}
 
std::vector<int*>::iterator iter;
 
for (iter = V.begin(); iter != V.end(); iter++)
{
          if (*(*iter)<0)
          {
             delete *iter;
             *iter = NULL;
             V.erase(iter);
           } 
}

Comment faire si le dernier élément est négatif pour que l'itérateur ne se perde pas.

Merci d'avance pour votre aide !

[TanEk]

La méthode erase renvoie un itérateur. C'est celui là que tu dois utiliser pour la suite de ton programme (car l'autre devient périmé : comme tu le dis parfois il peut pointer nulle part...). Je ne sais plus s'il renvoie l'itérateur d'après ou d'avant mais fais attention si c'est l'itérateur d'après :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
for (iter = V.begin(); iter != V.end(); iter++)
{
          if (*(*iter)<0)
          {
             delete *iter;
             iter = V.erase(iter);
             // Sortir si on est à la fin sinon iter++ va faire planter le programme
             if(iter == V.end()) break;
           } 
}

Essaye ça voir.

[donkeyquote]

Ok, c'est la solution que j'avais envisagé.

Je pensais que la STL prévoyait un mecanisme plus élégant pour gérer ce cas.

[Pacorabanix]

Ok, c'est la solution que j'avais envisagé.

Je pensais que la STL prévoyait un mecanisme plus élégant pour gérer ce cas.

perso je trouve justement que c'est élégant et pratique : pas besoin de redéfinir un nouvel itérateur, la fonction erase "passe le témoin" comme il faut.

[yan]

La méthode erase renvoie un itérateur. C'est celui là que tu dois utiliser pour la suite de ton programme (car l'autre devient périmé : comme tu le dis parfois il peut pointer nulle part...). Je ne sais plus s'il renvoie l'itérateur d'après ou d'avant mais fais attention si c'est l'itérateur d'après :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
for (iter = V.begin(); iter != V.end(); iter++)
{
          if (*(*iter)<0)
          {
             delete *iter;
             iter = V.erase(iter);
             // Sortir si on est à la fin sinon iter++ va faire planter le programme
             if(iter == V.end()) break;
           } 
}

Essaye ça voir.

NONNNNNNNNNNNNNNNNNNNNN.
Surtout pas comme ça. Vous allez zappé des valeurs!!!
FAQ :
http://cpp.developpez.com/faq/cpp/?p...ssion_elements

[donkeyquote]

Oki !!!

Merci Mongaulois !!
Je supçonnait qu'il y avait qqch qui clochait dans la solution proposée ...
D'ailleur j'avais également tort car c'était la façon dont j'avait pensé de resoudre le problème.

Je remercie aux autres aussi d'avoir essayé de m'aider

[yan]

Piuf....
J'ai sauvé cette coquille

[yan]

Cette solution est la moins performante... Tu perdra du temps par des recopie à chaque erase...
Le top c'est d'utiliser les algorithm :

Code :

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
26
27
28
//prédicat
struct supperieur_egale
{
supperieur_egale(int val =0)m_val(val){}
bool operator() (int* pval) { return *pval>= m_val;}
int m_val;
};
 
void mafonction()
{
 
 
 std::vector<int*> V;
// admettons que les éléments pointés sont  {4, -7, 8, 46, 31, -1}
std::vector<int*>::iterator iter= V.end();
//on met à la fin les pointeur qui ne sont pas supérieur ou égale à 0
std::vector<int*>::iterator itremove=std::partition(colony.begin(),itend ,supperieur_egale(0) );
//on delete les pointeur inutile
  list<Ant*>::iterator  it = itremove;
   while(it!=itend )
      {
      delete *it;
      ++it;
      }
//on les vire du vecteur
   V.erase(itremove,itend );
}
}

Je n'utilise pas l'algo remove car ce sont des pointeur qui sont stocké..
remove : utilise le égale dans une seul direction
partition : swap les valeurs

Pour les algo
http://r0d.developpez.com/articles/algos-stl/

[donkeyquote]

Merci !!
C'est super...
Je trouve que ce forum est réellement génial. On apprend plein des choses.