Discussion :

[master20]

Bonjour,

En programmant avec STL, J'ai une classe A (contenant deux attribut string X ey Y) et j'ai eu besoin d'une list<A> pour manipuler mes données.

Je voudrais afficher les éléments de ma liste en ordre croissant de l'attribut X.
Pour cela, j'ai passé par l'algorithme sort() qui reçoit entre un foncteur (qui est une méthode de la classe Foncteurs)qui prend deux objets de A (a1 et a2) et compare a1.X et a2.Y

Jusqu'ici, tout est correct. mon problème est: je voudrais également afficher mes données par ordre croissant de l'attribut Y. Pour cela, j'ai fait de même. j'ai donner à l'algorithme sort() un foncteur qui prend également deux objets de A (a3 et a4) et compare a3.Y et a4.Y. Cependant, lors de la compilation, il y a une ambiguité pour le foncteur qui trie suivant X et celui suivant Y. Ils ont la même signature, donc le compilateur ne sait pas quel foncteur prendre pour le bon tri. Comment je peux contourner ce problème ?

Merci

[Arzar]

Bonjour,
Peux tu nous montrer à quoi ressemble tes deux foncteurs et comment tu les passes à la fonction sort ?

[koala01]

Salut,
Le plus simple est de donner des noms différents à tes foncteurs, vu que, de toutes manières, tu les appelleras sans doute dans des contextes différents

Tu pourrait avoir un

Code :

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

1
2
3
4
5
6
7
8
 
struct lessByX
{
    bool operator()(A const & first, A const & second) const
    {
        return first.x() <second.x();
    }
};

et un

Code :

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

1
2
3
4
5
6
7
8
struct LessByY
 
{
    bool operator()(A const & first, A const & second) const
    {
        return first.Y() <second.Y();
    }
};

Tu fournirais donc "LessByX" si tu veux trier ta collection sur base de l'attribut X et LessByY si tu veux le faire sur base de l'attribut Y

Après, si l'idée est de travailler de manière générique (avec les templates), il est bon de se rappeler le bon vieil adage de

all problems in computer science can be solved by another level of indirection .

et d'envisager, pourquoi pas,
1- la création de deux flags proches de

Code :

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

1
2
struct XNeeded{};
struct YNeeded{};

2- la spécialisation d'un "getter" générique sous la forme de

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
template<typename Flag>
struct FlaggedGetter;
template<>
struct FlaggedGetter<XNeeded>
{
    std::string const & operator()(A const & a) const
    {
        return a.x();
    } 
};
template<>
struct FlaggedGetter<YNeeded>
{
    std::string const & operator()(A const & a) const
    {
        return a.y();
    } 
};

3- l'utilisation d'un foncteur générique proche de

Code :

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

1
2
3
4
5
6
7
8
template <typename Flag>
struct MyGenericLesser
{
    bool operator()(A const & first, A const & second) const
    {
        return FlaggedGetter<Flag>()(first) < FlaggedGetter<Flag>()(second);
    }
};

Et le tour serait joué

[oodini]

envisager, pourquoi pas,
1- la création de deux flags proches de

Code :

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

1
2
struct XNeeded{};
struct YNeeded{};

Pourquoi utiliser deux structures plutôt qu'un enum ?

[Bousk]

N'y aurait-il pas une histoire qu'un enum déclare des symboles, donc prend de la mémoire, là où une structure si elle n'est pas utilisée, ne consomme rien d'autre que des lignes de codes ?
Ca semble anecdotique, mais c'est toujours une information intéressante.

[ternel]

N'y aurait-il pas une histoire qu'un enum déclare des symboles, donc prend de la mémoire, là où une structure si elle n'est pas utilisée, ne consomme rien d'autre que des lignes de codes ?
Ca semble anecdotique, mais c'est toujours une information intéressante.

Je suis curieux d'en apprendre plus à ce sujet. As-tu une référence à conseiller?