Les comparateurs en STL

Je suis à l'aide struct minHeap pour générer un min tas à l'aide de priority_queue .Et la fonction comp pour imprimer les numéros dans l'ordre inverse à l'aide de la fonction de tri donnée dans la STL . Maintenant, mon doute, c'est que je ne peux pas utiliser struct minHeap dans la fonction de tri et ne pouvez pas utiliser la fonction comp dans priorityQueue .

J'ai l'impression que la fonction des deux struct minHeap et comp est similaire. Merci de m'expliquer quand utiliser les structures pour comaprator et quand utiliser les fonctions normales à se comporter comme des éléments de comparaison dans la STL ?

#include<iostream>
#include <queue>
#include <stdio.h>
#include<algorithm>
using namespace std;

struct minHeap
{
    bool operator()(const int a , const int b )
    {
        return a>b;
    }
};
bool comp(int a , int b)
{
    return a>b;
}

int main()
{
    priority_queue<int , vector<int> , minHeap > b;

    b.push(4);
    b.push(23);
    b.push(12);
    while(b.size()!=0)
    {
        cout << b.top() << " " ;
        b.pop();
    }
    cout<<"\n" ;
    int arr[] = {12,34, 112,12};
    sort(arr , arr+4  ,comp);

    for(int x= 0 ; x < 4 ; x++)
    {
        cout << arr[x] << " " ;
    }
}

double possible de la Comparaison Foncteur Types de contre l'opérateur<

OriginalL'auteur Arpit Agarwal | 2012-09-20

c++comparator stl

6

Ce que vous cherchez en général, c'est quand pour utiliser les fonctions ou lors de l'utilisation de les foncteurs.

La réponse courte est: Utilisez un foncteur si et seulement si vous avez besoin de conserver de l'état à travers de multiples appels à l'opérateur. Pour les fonctions de comparaison ce n'est généralement pas le cas, mais il existe d'autres cas d'usages tels que les accumulateurs, averagers, min/max calculatrices, etc.

Une autre question qui semble couvrir un terrain similaire et qui peut vous aider avec plus de détails et des références à des documents externes: Comparaison Foncteur Types vs opérateur<

De passage d'une fonction réelle à priority_queue - il n'est pas évident, mais il est possible:
```
typedef bool(*CompareFunc)(float, float); //You need to have your function pointer 
                                          //type available
bool Compare(float i_lhs, float i_rhs)    //The actual compare function matching the 
  {                                       //CompareFunc type
  //Do your compare stuff here.
  }

...
std::priority_queue<float, std::vector<float>, CompareFunc> p(Compare);
//Tell priorityqueue you're passing a compare *function*, and pass the actual function
//as a parameter.
```
Il serait impossible d'utiliser une fonction dans le priority_queue exemple, même si il n'est pas en état de tenir entre les appels.
Vous pouvez, en fait - et il a fallu un certain temps pour le trouver, mais je poste le code maintenant dans un montage.

OriginalL'auteur Joris Timmermans
5

Vous pouvez utiliser un foncteur en sort(), pas de problème:
```
sort(arr , arr+4  ,minHeap());
```
Peut-être que votre problème est que vous venez d'utiliser le nom de la classe (minHeap) à la place d'une instance de functor. minHeap() est un appel au constructeur de la classe, de ne pas operator().

Comme pour priority_queue, il est spécifié comme suit:
```
template < class T, class Container = vector<T>,
           class Compare = less<typename Container::value_type> > class priority_queue;
```
Par conséquent, vous avez besoin d'un nom de classe (par opposition à une instance) pour le troisième argument de modèle. Si vous souhaitez utiliser une fonction, vous devez utiliser un pointeur vers un type de fonction en tant que troisième argument de modèle et de passer ensuite le pointeur de fonction dans le constructeur:
```
priority_queue<int , vector<int> , bool (*)(int a, int b) > b(&comp);
```
OriginalL'auteur Gorpik

Vous devez vous connecter pour publier un commentaire.