[débutant] priority file et redéfinition de la comparaison

Bonjour,
Je souhaite utiliser une priority file de la STL, y placer des variables de type Sommet, et avoir comme critère de priorité un des champs de la structure Sommet. Je n'arrive pas à trouver la syntaxe correcte. Ce que j'ai trouvé dans la faq m'a plus embrouillé qu'aidé car c'est la première fois que j'utilise la STL et les tempaltes, et j'ai encore du mal à comprendre...

voilà ce que j'ai écrit:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 struct cmp { bool operator ()(const Sommet& s1 , const Sommet& s2) { return(s1.abs < s2.abs); }; }; typedef std::priority_queue<Sommet, deque<Sommet>, cmp<Sommet> > file; file tas;
et j'ai comme message d'erreur : non-template type `cmp' used as a template . Que dois-je changer dans mon code?
Merci d'avance

Code:

1
2
3
4
typedef std::priority_queue<Sommet,
                              deque<Sommet>,
                              cmp
                             > file;

Puisque cmp n'attend aucun paramètre template.

merci beaucoup, c'était pas trés compliqué
mais j'ai une autre question

je voudrais ne pas faire porter le critère de priorité sur un des champs de Sommet, mais sur la case d'un tableau dont l'indice dépend des champs de Sommet (c'est un peu tordu mais j'ai pas vraiment trouvé d'autre solution)

en fait, tout ça se trouve dans une méthode, j'ai un tableau que je déclare au début de la méthode:
Code:

1 2 int* tab= new int[n]
et ensuite
Code:

1 2 3 4 5 6 7 8 9 10 11 12 struct cmp { bool operator ()(const Sommet& s1 , const Sommet& s2 ) { return(tab[s1.x]>tab[s2.x]); }; }; typedef std::priority_queue<Sommet, deque<Sommet>, cmp > file;
est-ce que cela est possible? our l'instant il n'a pas l'air de l'accepter, j'ai de nombreux messages d'erreur à la compilation
merci d'avance

Un type utilisé comme paramètre template ne peut pas être un type local à une fonction, donc non ce n'est pas possible.

Par contre rien ne t'empêche de passer ton tableau en paramètre du foncteur, via son constructeur.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
struct cmp
{
    cmp(const int* T) : tab(T) {}
 
     bool operator ()(const Sommet& s1 , const Sommet& s2 ) const
     {
          return(tab[s1.x]>tab[s2.x]);
     }
 
private :
 
    const int* tab;
}; 
 
typedef std::priority_queue<Sommet,
                              deque<Sommet>,
                              cmp
                             > file;
 
int* tab = new tab[n]; // pourquoi pas un std::vector ?
 
file MaFile(cmp(tab)); // constructeur de std::priority_queue à vérifier, mais ça devrait être ça

j'ai à la compilation le message d'erreur:

Dijkstra.cpp: In method `void Dijkstra::cout (TableauBiDim, TableauBiDim)':
Dijkstra.cpp:60: template-argument `Dijkstra::cout (TableauBiDim, TableauBiDim)::cmp' uses local type `Dijkstra::cout (TableauBiDim, TableauBiDim)::cmp'
Dijkstra.cpp:60: confused by earlier errors, bailing out

où Dijkstra::cout est la méthode où se trouve tout ça, et la ligne 60 celle où il y a " > file; "

bon, j'ai réglé le problème précédent, il fallait juste sortir tout ça de la méthode dans laquelle ça se trouvait

donc le code suivant:

Code:

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
 
  struct cmp {
 
         cmp(const S* T} : tab(T) {}
 
         bool operator ()(const Sommet& s1 , const Sommet& s2) const
         {
 
                 return(tab[s1.x]>tab[s2.x]);
 
         }
  private:
  	const S* tab;
  };
 
  typedef std::priority_queue<Sommet,
                              deque<Sommet>,
                              cmp
                             > file;
 
void A::B()
{
  int m=5;
 
  S* traites= new S[m];
 
  file tas (traites);
 
  ...
}

compile

mais en fait je voudrais aussi passer en paramètre l'entier m pour pouvoir avoir dans operator () quelque chose de la forme tab[s1.x*m]

mais quand je compile:

Code:

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
 
  struct cmp {
 
         cmp(const S* T , const int x} : tab(T) , m(x) {}
 
         bool operator ()(const Sommet& s1 , const Sommet& s2) const
         {
 
                 return(tab[s1.x]>tab[s2.x]);
 
         }
  private:
  	const S* tab;
                const int m;
  };
 
  typedef std::priority_queue<Sommet,
                              deque<Sommet>,
                              cmp
                             > file;
 
void A::B()
{
  int m=5;
 
  S* traites= new S[m];
 
  file tas (traites,m);
 
  ...
}

j'ai le message d'erreur : no matching function for call to `priority_queue<Sommet, deque<Sommet, allocator<Sommet>, 0>, cmp>::priority_queue (S *&, int)

où est l'erreur ?

Citation:
Envoyé par Romain93
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 struct cmp { cmp(const S* T} : tab(T) {} /**/ }; typedef std::priority_queue<Sommet, deque<Sommet>, cmp > file; void A::B() { int m=5; S* traites= new S[m]; file tas (traites); ... }
Ici, le code marche, mais pas comme tu le penses. L'argument attendu par le constructeur de ta priority_queue est un objet du type cmp. Il se trouve que comme cmp a un constructeur à un seul argument, de type S*, non déclaré explicit (essaye d'ajouter ce mot clef devant le constructeur pour voir), ce constructeur peut servir à convertir implicitement un S* en cmp. C'est ce qui se passe.
Citation:
Envoyé par Romain93
Code:

1 2 3 4 5 6 7 8 9 10 11 12 struct cmp { cmp(const S* T , const int x} : tab(T) , m(x) {} }; void A::B() { int m=5; S* traites= new S[m]; file tas (traites,m); ... }
Ici, un constructeur à 2 paramètre ne peut plus servir à la conversion. Et tu passes deux paramètres au constructeur de priority_queue qui n'en attend qu'un seul. Donc boom.

La solution : Lui passer un objet de type cmp que tu auras construit explicitement avec les bonnes valeurs :

Code:

file tas (cmp(traites,m));

bien vu, merci beaucoup
au début j'avais bien mis file tas (cmp(traites)); maisj'avais changé parceque ça compilait pas alors qu'en fait c'était pour autre chose

bref, merci beaucoup!