Afficher Template par odre croissant et décroissant

Salut,

A vrai dire, je ne vois pas vraiment pourquoi essayer d'utiliser la std::queue et la std::dequeue...

Le plus facile serait, à mon sens, d'utiliser un "simple" tableau deux foncteurs bien adaptés:

Le premier permettrait de trier les éléments dans l'ordre croissant:

Code:

1
2
3
4
5
6
7
8
9
10
11
struct AscendentLess
{
    bool operator()(Personne const & first, Personne const & second)
    {
        /* comme je n'ai aucune information concernant la classe Personne
         * je vais partir du principe que tu veux trier les éléments sur base
         * de leur noms ;)
         */
         return first.nom()<second.nom();
    }
};

Le second permettrait de trier les élément dans l'ordre décroissant:

Code:

1
2
3
4
5
6
7
8
struct DescendentLess
{
    bool operator()(Personne const & first, Personne const & second)
    {
        /* même remarque que plus haut ;) */
        return first.nom()> second.nom();
    }
};

Pour éviter de lancer une requète de tri lorsque ce n'est pas nécessaire (entre autre si le tri souhaité est déja effectué), j'adjoindrait volontiers une énumération proche de

Code:

1
2
3
4
5
6
enum ActualSort
{
    unsorted,
    ascendentSorted,
    descendentSorted
};

et, pour faire bonne mesure, je créerais mes propres fonctions d'ajout, de tri ascendant et de tri descendant:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
void ascendentSort(std::vector<Personne> & tab, ActualSort & actual)
{
    if(actual != ascendentSorted)
    {
        std::sort(tab.begin(), tab.end(),AscendentLess());
        actual=ascendentSorted;
    } 
}
void descendentSort(std::vector<Personne> & tab, ActualSort & actual)
{
    if(actual != descendentSorted)
    {
        std::sort(tab.begin(), tab.end(),AscendentLess());
        actual=descendentSorted;
    } 
}
void addPerson(std::vector<Personne> & tab, ActualSort &actual, Personne
               const & p)
{
    tab.push_back(p);
    actual = unsorted; // force le tri quel que soit le sens ;)
}

Le tout serait utilisé sous une forme proche de

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
int main()
{
    ActualSort actual;
    std::vector<Personne> tab;
    /* le remplissage du tableau */
    Personne p(/* paramètres éventuels */);
    addPerson(tab, actual, p);
    /* si on veut un affichage dans l'ordre croissant */
    ascendentSort(tab, actual);
    for(std::vector<Personne>::const_iterator it=tab.begin();it!=tab.end();
        ++it)
    {
        /* affichage des éléments */
    }
    /* si on veut un affichage dans l'ordre décroissant */
    descendentSort(tab, actual);
    for(std::vector<Personne>::const_iterator it=tab.begin();it!=tab.end();
        ++it)
    {
        /* affichage des éléments */
    }
    return 0;
}