Discussion :

[Invité]

Bonjour,

Je voudrais créer une fonction "trierListe" qui fonctionne avec des std::list et std::vector (voir code ci-dessous)

Est-ce possible ? (si oui, comment compléter la fonction "trierListe" ci-dessous ?)

NB : je rappelle que les std::vector et std:list se trient avec des méthodes un peu différentes ( voir fonction "trierListe" )

En fait le tri est un prétexte, je voudrais juste savoir quel est le type de liste reçu dans ma fonction trierListe avec template.

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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
#include <stdlib.h>
#include <iostream>
 
#include <string>
#include <vector>
#include <list>
 
using namespace std;
 
class A {
   string strNom_;
 
public:
 
   A( const char * szNom) : strNom_( szNom ) {};
 
   // Opérateur de comparaison par défaut pour std::sort
   friend bool operator < (const A & a1, const A & a2) {
      return (a1.strNom_ < a2.strNom_ );
   }// operator <
 
   // Opérateur de sortie des flots
   friend std::ostream& operator<<( std::ostream& oss ,
                                    const Animal& a ) {
      oss << a.strNom_;
      return oss;
   }// operator<<
 
};// A
 
 
template<class L>
void afficherListe( L liste ) {
   typename L::iterator it;
   for ( it = liste.begin() ; it != liste.end(); ++it )
      cout << *it << endl;
}// afficherListe
 
 
template<class L>
void trierListe ( L & liste ) {
  //if ( liste est de type vector ) {
    sort( liste.begin(), liste.end() );
  //}
  //else if ( liste est de type std::list ) {
    liste.sort();
  //}
}// trierListe
 
 
int main(int argc, char *argv[]) {
   vector<A> lstV;
   //remplirListe( lstV );
 
   list<A> lstL;
   //remplirListe( lstL );
 
   // Tris 
   trierListe( lstV );
   trierListe( lstL );
 
   cout << "Liste \"vector\" apres tri ascendant" << endl;
   afficherListe( lstV );
   cout << endl;
   cout << "Liste \"list\" apres tri ascendant" << endl;
   afficherListe( lstL );
 
   system( "pause" );
   return EXIT_SUCCESS;
}// main

[yan]

bonjour,
en faisant des spécialisation. Il me semble que comme ca ca marche :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
template<class L>
void trierListe ( std::list<L> & liste ) {
 
    liste.sort();
}
 
template<class L>
void trierListe ( std::vector<L> & liste )
{
     sort( liste.begin(), liste.end() );
 }

[Albenejean]

Uhmmm...
Je n'ai jamais testé, et je ne veux pas dire de bétise, mais il me semble que les méthodes make_heap() et sort_heap() pouraient t'aider.
La première crée un tas à partir de deux itérateurs et la deuxième permet de trier ce tas.

[yan]

Uhmmm...
Je n'ai jamais testé, et je ne veux pas dire de bétise, mais il me semble que les méthodes make_heap() et sort_heap() pouraient t'aider.
La première crée un tas à partir de deux itérateurs et la deuxième permet de trier ce tas.

Le heap est une autre structure. Elle fonctionne qu'avec des random iterator. comme sort. Donc cela ne marchera pas avec les liste...

[yan]

avec la spécialisation ça marche au poile

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
24
25
26
27
28
29
30
31
32
33
 
#include <iostream>
#include <list>
#include <vector>
using namespace std;
 
template<class L>
void trierListe ( L & liste ) {
cout<<"trierListe de base"<<endl;
}
 
template<class L>
void trierListe ( list<L> & liste ) {
cout<<"trierListe de list"<<endl;
}
 
template<class L>
void trierListe ( vector<L> & liste )
{
  cout<<"trierListe de vector"<<endl;
 }
 
int main()
{
    int * myTabC = new int[10];
    list<int> myList;
    vector<int> myVect;
 
    trierListe(myTabC);
   trierListe(myList);
   trierListe(myVect);
    return 0;
}

[Laurent Gomila]

A noter que là ce ne sont pas des spécialisations, mais plutôt des surcharges.

[Invité]

avec la spécialisation ça marche au poile

Effectivement, ça fonctionne bien, merci.

Mais mon objectif était de n'avoir qu'une seule fonction.

Il n'y a donc par moyen de savoir, dans "trierListe", quel est le type de liste que l'on reçoit ?

[yan]

IL y as aussi
typeid
http://www.cplusplus.com/doc/tutorial/typecasting.html
mais je ne connait pas trop