Discussion :

[loacast]

Bonjour,

J'ai une classeA qui contient un "vector<ClasseB>* ".

Je suis en train de créer une fonction qui compare l'égalité entre le pointeur passé en paramètre "ClasseB* lePointeur" et tous les pointeurs contenus dans le vector de la classeA.

Hors, je n'arrive pas à tester ce cas car apparemment il y'a un problème de surcharge d'opérateur. Mais c'est là où c'est triste puisque c'est bien l'adresse pointée que je cherche à testé et non l'objet lui même.

Dans l'espoir que vous puissiez m'aider, je vous remercie.

[pottiez]

Un peut de code pour nous éclairer ?

normalement ceci devrait fonctionner :

Code :

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

1
2
3
4
5
6
bool present = false ;
for(i=0;i<monVector.size();i++){
  if(monVector[i] == lePointeur){
    present = true ;
  }
}

[loacast]

Normallement oui, malheureusement cela ne fonctionne pas :

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
29
30
 
 
void CollectionPrimitives::Supprimer(Primitive* unePrimitive)
{
   unsigned int i = 0;
   bool finRecherchePrimitive = false;
 
   do
   {
      if (i < this->Primitives->size())
      {
         if (this->Primitives[i] == unePrimitive)
         {
            finRecherchePrimitive = true;
         }
         else
         {
            i++;
         }
      }
      else
      {
         finRecherchePrimitive = true;
      }
   }
   while (finRecherchePrimitive);
 
   // en développement
 
}

[pottiez]

Pourquoi fait tu si compliqué (boucle do{ }while()), alors que le for est si simple :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
void CollectionPrimitives::Supprimer(Primitive* unePrimitive)
{
  unsigned int i ;
  bool trouve = false;  
  for(i=0;i<this->Primitives->size();i++){
    if(this->Primitives[i] == unePrimitive){
      trouve = true ;
      break ;
    }
  }
  //reste du code ;
}

[loacast]

La n'est pas la question mais puisqu'on en parle, je n'aime pas le break, et je l'utilise quasiment jamais.

[pottiez]

Oui mais est ce qu'avec ce code ca fonctionne ou ca ne fonctionne pas non plus ?

[loacast]

Non mais c'est normal puisque le problème ne vient apparement pas de la boucle mais bien de la comparaison.

Le message d'erreur exact est :

no match for 'operator==' in '*(((CollectionPrimitives*)this)->CollectionPrimitives:rimitives + (+(i * 12u))) == unePrimitive'

Peut-être cela te parles t-il plus ? Moi je patoge .

[pottiez]

le code que tu m'as passé est le bon ou c'est une version simplifié, le message d'erreur fait etat de plus de code non ?

[loacast]

Voici la classe qui contient le vector :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
 
class CollectionPrimitives
{
 
   public:
      std::vector<Primitive>* Primitives;
 
   public:
      void Ajouter(Primitive* unePrimitive);
      void Supprimer(Primitive* unePrimitive);
 
};

[pottiez]

Pour supprimer un objet d'un vector il suffit de faire ceci :

Code :

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

1
2
3
4
void CollectionPrimitives::Supprimer(Primitive* unePrimitive)
{
  Primitives.erase(unePrimitive) ;
}

Ca simplifiera peut être le traitement.

[loacast]

Je suppose que ça devrait résoudre le problème dans ce cas là, cependant, je vais devoir faire d'autres recherches de ce style pour d'autres fonctionnalités et donc si quelqu'un a déjà eu ce problème ou devine de quoi il peut s'agir je lui en serait très reconnaissant.

En attendant merci pottiez pour ton aide.

[pottiez]

De rien, je trouve tout de même bizarrd qu'il ne trouve pas les adresses correctement.
A plus

[loacast]

J'ai réellement un problème avec mon programme, cela ne fonctionne pas ??

Code :

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

1
2
3
 
 
this->Primitives->erase(unePrimitive);

[Luc Hermitte]

Pourquoi vous faites compliqué alors que std::find et std::find_if nous tendent les bras ?

Sinon, truc très bizarre. Le vecteur est géré via un pointeur. C'est contre productif. De plus, c'est un vecteur de primitives et non de primitive*, chose que tu reçois dans add().

Enfin, la question la plus importante de toutes : es-tu sûr que l'on pourra toujours passer des pointeurs vers primitives pour les recherches ? En général, on a des critères particuliers et on veut chercher les éléments qui vérifient ces critères. Attention de ne pas tomber dans le piège de créer un nouveau Primitive à la volée et de chercher cet élément.

[loacast]

Sinon, truc très bizarre. Le vecteur est géré via un pointeur. C'est contre productif.

Pourrais tu argumenter la-dessus s'il te plait car ça m'intéresse.

De plus, c'est un vecteur de primitives et non de primitive*, chose que tu reçois dans add().

Je ne comprend pas ce que tu veux dire ? C'est bien un vecteur de Primitive* :

Code :

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

std::vector<Primitive>* Primitives;

es-tu sûr que l'on pourra toujours passer des pointeurs vers primitives pour les recherches ?

oui

Attention de ne pas tomber dans le piège de créer un nouveau Primitive à la volée et de chercher cet élément.

Alors là je ne comprend encore moins ce à quoi tu fais référence. Pourquoi veux tu que je crée un objet Primitive ?

[Luc Hermitte]

Non. Tu as écris pointeur sur vecteur de primitive. Et non vecteur de pointeurs sur primitives.

Alors là je ne comprend encore moins ce à quoi tu fais référence. Pourquoi veux tu que je crée un objet Primitive ?

Une méfiance naturelle qui s'est développée avec mon odorat qui repère les problèmes à la c*n.
Généralement, si on peut recevoir un pointeur cela signifie que c'est l'objet lui-même qui va chercher à se retirer de la liste, on un autre objet qui stocke une référence (au sens génral et non C++) vers l'objet à retirer. Sinon, on a eu avant une recherche sur un critère qui qui permettait de trouver l'objet à retirer. Et si c'est le cas, alors on a un itérateur et donc autant utiliser directement l'itérateur dans l'erase.

[loacast]

Non. Tu as écris pointeur sur vecteur de primitive. Et non vecteur de pointeurs sur primitives.

Merci, tu viens de trouver la solution à mon problème .

Pour ce qui est de l'objet, il n'est pas géré par mes classes, il est géré dans le main. Le but est de créer un code qui permettra au programmeur de faire de simple programme 3D sans toucher à OpenGL. Pour ce faire, je stocke le pointeur de l'objet à afficher lorsque l'utilisateur utilise l'opérateur <<. La suppression du pointeur se fera à la destruction de l'objet donc à priori, cela ne devrait pas poser de problème.