Discussion :

[d.zives]

Je viens à vous car je ne comprends pas l'erreur suivante :

: request for member ‘x’ in ‘* it.std::_Rb_tree_const_iterator<_Tp>::operator-> [with _Tp = truc*]()’, which is of non-class type ‘truc* const’

du code suivant

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
 
struct truc
{
    int x; int y;
} machin;
 
void allo()
{
    set<truc *> jj;
    jj.insert(&machin);
 
    for (set <truc*> ::iterator it = jj.begin(); it != jj.end(); ++it)
    {
        it->x;
    }
 
}

Merci à vous de m'expliquer pourquoi le code ci-dessus ne marche pas.

[koala01]

Salut, et bienvenue sur le forum.

Le fait est que la collection "set" utilise son contenu comme clé de tri.

Si tu envisage de modifier l'élément contenu, tu risque de... modifier la clé, et donc de "bousiller" le tri qui a été fait.

C'est la raison pour laquelle tu ne peux utiliser qu'un... const_iterator lorsque tu souhaite accéder aux éléments contenu dans un std::set: cela permet au compilateur d'avoir la certitude que, quoi que tu fasse, l'élément ne sera pas modifié, et que le tri restera donc valide.

[d.zives]

Ok je comprends mieux.
Mais de cette façon comme puis-je accéder à l'élément x ou y?

[d.zives]

Parce qu'en fait le but c'est de trier selon l'adresse. J'aimerai juste modifier le contenu..

[koala01]

Le fait est que tu place déjà un... pointeur sur ta structure dans ton set et qu'un itérateur (constant) a... sémantique de pointeur.

au départ de ton itérateur (constant) tu dois donc travailler comme si tu disposais en réalité... d'un pointeur de pointeur.

Tu ne pourra donc accéder (en lecture uniquement) à x ou à y que... si tu travaille au départ de "ce qui est pointé par" ton itérateur (constant) ton code (que je copie malgré un grand nombre de défauts connexes ) devrait donc ressembler à

Code :

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

1
2
3
4
5
6
7
8
9
10
11
void allo()
{
    set<truc *> jj;
    jj.insert(&machin);
 
    for (set <truc*> ::const_iterator it = jj.begin(); it != jj.end(); ++it)
    {
        (*it)->x;
    }
 
}

[koala01]

Parce qu'en fait le but c'est de trier selon l'adresse. J'aimerai juste modifier le contenu..

Le fait est que machin est une variable globale, qui n'existe que de manière visiblement unique...

Tu n'as donc de toute manière aucun intérêt à vouloir le trier en fonction de l'adresse, vu que tu n'as... qu'une seule donnée

Si tu décidais de travailler sur plusieurs données différentes, tu pourrais envisager de créer ta propre fonction de comparaison "plus petit que" qui comparerait les adresses de tes données.

Tu aurais donc un structure proche de

Code :

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

1
2
3
4
5
 
struct truc
{
    int x; int y;
}

et une collection (on va utiliser la classe "vector", pour la facilité ) que tu remplirait sous une forme proche de

Code :

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

1
2
3
4
5
int main()
{
    std::vector<truc> tab(10); // on profite du fait que truc est défaut
                               // constructible ;)
}

On créerait un foncteur (une "fonction objet") qui assurerait la comparaison plus petit que

Code :

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

1
2
3
4
5
6
7
8
struct CompAddress
{
    bool operator()(truc const& t1, truc const & t2)
   {
        return &t1 < &t2; // renvoie vrai SSI l'adresse de t1 est plus petite
                          // que celle de t2
   }
};

Et nous pourrions alors utiliser l'algorithme de tri "sort" fourni par le standard dans l'espace de noms std par inclusion du fichier d'en-tête <algorithm> sous une forme proche de

Code :

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

1
2
3
std::sort(tab.begin(), // itérateur sur le premier élément
          tab.end(), // itérateur sur ce qui suit le dernier élément
          CompAddress() ); //une instance de notre foncteur

Si tu veux utiliser des objets alloués dynamiquement, et donc gérer directement une collection de pointeurs sur truc, le remplissage s'effectuerait sous la forme de

Code :

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

1
2
3
4
5
6
int main()
{
    std::vector<truc*> tabPtr;
    for(int i=0;i<10;++i)
        tabPtr.push_back(new truc);
}

et le foncteur prendrait la forme de

Code :

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

1
2
3
4
5
6
7
8
struct CompAddress
{
    bool operator()(truc const *& t1, truc const *& t2)
   {
        return t1 < t2; // renvoie vrai SSI l'adresse de t1 est plus petite
                        // que celle de t2
   }
};

(le tri restant identique)

Nota: il ne faudra pas oublier de libérer correctement la mémoire allouée à chacun des éléments de type truc lorsque tu n'en aura plus besoin

[d.zives]

Merci de votre réponse. Ça parait très clair maintenant.
Néanmoins j'avais crée ce code à titre d'exemple d'erreur. Il n'est pas tiré d'un vrai code sinon il serait complétement absurde.

[koala01]

Merci de votre réponse. Ça parait très clair maintenant.
Néanmoins j'avais crée ce code à titre d'exemple d'erreur. Il n'est pas tiré d'un vrai code sinon il serait complétement absurde.

Le problème, c'est que l'on ne dispose jamais que des informations que la personne qui pose la question nous donne.

On ne peut donc se baser que sur ces informations, et, si elles ne sont pas correctes, on part, forcément, dans des déductions incorrectes.

Je comprends parfaitement que l'on ait quelques scrupules à présenter son code réel sur le forum, mais il faut au moins veiller à présenter un code minimum compilable qui reproduit effectivement le problème auquel on est confronté, ne serait-ce que pour permettre à ceux qui essayeront de répondre de... tirer les bonnes conclusions

Il serait peut être intéressant pour toi de lire et de réfléchir un peu à la signification de ma signature avant de poser tes prochaines questions, si tu souhaite obtenir une réponse rapide et efficace