Discussion :

[CliffeCSTL]

Bonjour,

Je souhaite coder un une fonction de tri qui prend en entrée un pointeur sur une liste d'objets et qui me tri cette liste en fonction d'un attribut de l'objet.

Code :

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

1
2
3
4
class A {
    private:
        int a, b, c;
}

Code :

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

1
2
3
4
class B {
    private:
        double d, e;
}

Ma fonction doit pouvoir triée des listes d'objets de type A et B suivant l'attribut que je veux.

Merci.

[Neckara]

Bonjour,

On ne codera pas la fonction à ta place.
Dis-nous ce qui te bloque/ce qui te gêne/ce que tu as déjà fait/tenté et on pourra t'aider.

[CliffeCSTL]

Je vois pas comment faire c'est tout :p. C'est faisable au moins ?

[_zzyx_]

Une bonne pratique c'est de ne pas ré-inventer la roue,
Regarde plutôt de ce coté là
http://www.cplusplus.com/reference/list/list/sort/
http://www.cplusplus.com/reference/algorithm/sort/
Surtout que pour un tri générique, il sera dur de faire mieux que la STL (où alors tu n'aurais pas besoin de poser la question sur ce forum)

Dans certains cas il se peut que tu veuilles implémenté un algo précis, mais il faudra nous en dire plus

[CliffeCSTL]

Je pense pas que se que je demande existe déjà.

Si je reprend mon exemple de la classe A :

Code :

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

1
2
3
4
5
6
7
8
class A {
    private:
        int a, b, c;
    public:
        A(int inA, int inB, int inC) { 
            a = inA; b = inB; c = inC;
        }
}

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
int main() {
    A a1(1, 2, 3), a2(3, 1, 2), a3(2, 3, 1);
    QList<A> listeATrier;
 
    listeATrier.push_back(a1);
    listeATrier.push_back(a2);
    listeATrier.push_back(a3);
 
    cout << listeATrier << "\n";
 
    // Tri décroissant
    Sort(listeATrier, A::a); cout << listeATrier;
    Sort(listeATrier, A::b); cout << listeATrier;
    Sort(listeATrier, A::c); cout << listeATrier;
}

Code :

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

1
2
3
4
5
6
console :
a1, a2, a3
 
a2, a3, a1
a3, a1, a2
a1, a2, a3

J'écris n'importe quoi mais c'est pour comprendre

[white_tentacle]

En fait ce que tu veux faire nécessite un mécanisme d’introspection, pas présent en standard en c++.

Donc en C++, tu ne peux pas trier selon un « attribut », tu peux trier en revanche selon un « comparateur ».

Donc ce que tu veux faire serait plus proche de :

Code :

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

1
2
3
4
 
   Sort(listeATrier, compareAOnA); cout << listeATrier;
    Sort(listeATrier, compareAOnB); cout << listeATrier;
    Sort(listeATrier, compareAOnC); cout << listeATrier;

[CliffeCSTL]

Moi je veux triée par rapport aux attributs.

[Médinoc]

En fait ce que tu veux faire nécessite un mécanisme d’introspection, pas présent en standard en c++.

Donc en C++, tu ne peux pas trier selon un « attribut », tu peux trier en revanche selon un « comparateur ».

Je ne vois pas en quoi tu ne pourrais pas, avec le code qu'il faut:

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
template<class obj, class attr>
struct comparateur_attribut
{
	attr obj::* pAttribut;
	bool operator() (obj const &left, obj const &right)
	{
		return left.*pAttribut < right.*pAttribut;
	}
};
 
template<class obj, class attr>
sort(QList<obj> &objetsATrier, attr obj::* pAttribut)
{
	//obtenir itérateurs
	//...
	comparateur_attribut cmp;
	cmp.pAttribut = pAttribut;
	std::sort(itDebut, itFin, cmp);
}
 
    Sort(listeATrier, &A::a); cout << listeATrier;
    Sort(listeATrier, &A::b); cout << listeATrier;
    Sort(listeATrier, &A::c); cout << listeATrier;

[Luc Hermitte]

Code :

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

1
2
std::vector<A> liste { {1, 2, 3}, {3, 1, 2}, {2, 3, 1} };
std::sort(liste.begin(), liste.end(), [](A const& lhs, A const& rhs) {return lhs.b < rhs.c; });

Tu peux aussi t'amuser à définir des foncteurs qui vont simplifier l'écriture.

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <iterator>
 
struct A {
    int a;
    float b;
    std::string c;
    friend std::ostream & operator<<(std::ostream & os, const A & v)
    {
        return os << "{" << v.a << ", " << v.b << ", " << v.c << "}";
    }
};
 
template <class T, class V> struct sort_by_impl {
    sort_by_impl(V T::*p) : m_p(p) {}
    bool operator()(T const& lhs, T const& rhs) const
    { return lhs.*m_p < rhs.*m_p; }
private:
    V T::*m_p;
};
 
template <class T, class V> sort_by_impl<T,V> sort_by(V T::*p) { return sort_by_impl<T,V>(p); }
 
int main ()
{
    std::vector<A> a{
        {1, 12.5, "z"},
        {2, 2.5, "b"},
        {3, 42.5, "a"}
    };
    std::copy(a.begin(),a.end(), std::ostream_iterator<A>(std::cout, "\n"));
 
    std::cout << "a\n";
    std::sort(a.begin(),a.end(), sort_by(&A::a));
    std::copy(a.begin(),a.end(), std::ostream_iterator<A>(std::cout, "\n"));
    std::cout << "b\n";
    std::sort(a.begin(),a.end(), sort_by(&A::b));
    std::copy(a.begin(),a.end(), std::ostream_iterator<A>(std::cout, "\n"));
    std::cout << "c\n";
    std::sort(a.begin(),a.end(), sort_by(&A::c));
    std::copy(a.begin(),a.end(), std::ostream_iterator<A>(std::cout, "\n"));
}
// Vim: let $CXXFLAGS='-std=c++0x'